diff --git a/.gitignore b/.gitignore index a5d6201ae..cc4a9ada3 100644 --- a/.gitignore +++ b/.gitignore @@ -8,8 +8,10 @@ __dummy.html /tilix __test__library__ .vscode +.idea/ backup tilix.gresource +gschemas.compiled data/pkg/arch/pkg data/pkg/arch/src data/pkg/desktop/com.gexperts.Tilix.desktop diff --git a/CREDITS.md b/CREDITS.md index 45b444fba..623b4ad55 100644 --- a/CREDITS.md +++ b/CREDITS.md @@ -16,6 +16,7 @@ please feel free to let me know or update this file via a pull request. * Matthias Clausen * Christian Herget * Allan Day +* Dejan Lekić (migration to giD, and various other improvements after the migration) While not directly contributing to Tilix, I would also like to thank the following people and organizations for their contributions to projects without whose existence @@ -25,3 +26,4 @@ Tilix would not exist. * Mike Wey for GtkD * The D Foundation * Gnome Project, http://www.gnome.org +* Element Green for the gidgen and [giD](https://github.com/Kymorphia/gid) projects. diff --git a/GTKD-TO-GID-NOTES.md b/GTKD-TO-GID-NOTES.md new file mode 100644 index 000000000..9e3019668 --- /dev/null +++ b/GTKD-TO-GID-NOTES.md @@ -0,0 +1,1748 @@ +# GtkD to GID Migration Notes + +This document captures all patterns, problems, and solutions discovered during the migration of Tilix from GtkD to GID bindings. + +--- + +## Table of Contents + +1. [Import Path Changes](#1-import-path-changes) +2. [Signal Connections](#2-signal-connections) +3. [Enum Naming Conventions](#3-enum-naming-conventions) +4. [Constructor Patterns](#4-constructor-patterns) +5. [Property Access](#5-property-access) +6. [C API Fallback Patterns](#6-c-api-fallback-patterns) +7. [Type System Differences](#7-type-system-differences) +8. [Common Problems and Solutions](#8-common-problems-and-solutions) +9. [Memory Management](#9-memory-management) +10. [Platform-Specific Considerations](#10-platform-specific-considerations) + +--- + +## 1. Import Path Changes + +GID uses snake_case for module names instead of GtkD's PascalCase. + +### General Pattern + +| GtkD | GID | +|------|-----| +| `gtk.Window` | `gtk.window` | +| `gtk.ApplicationWindow` | `gtk.application_window` | +| `gtk.MessageDialog` | `gtk.message_dialog` | +| `gtk.CssProvider` | `gtk.css_provider` | +| `gtk.StyleContext` | `gtk.style_context` | +| `gdk.RGBA` | `gdk.rgba` | +| `gdk.Screen` | `gdk.screen` | +| `gio.Settings` | `gio.settings` | +| `gio.SimpleAction` | `gio.simple_action` | +| `glib.Variant` | `glib.variant` | +| `glib.VariantType` | `glib.variant_type` | +| `gobject.ObjectG` | `gobject.object` | +| `gobject.ParamSpec` | `gobject.param_spec` | +| `vte.Terminal` | `vte.terminal` | +| `cairo.Context` | `cairo.context` | +| `cairo.ImageSurface` | `cairo.surface` (see note below) | +| `pango.PgFontDescription` | `pango.font_description` | +| `gdkpixbuf.Pixbuf` | `gdkpixbuf.pixbuf` | + +### Special Import Cases + +#### Cairo ImageSurface +GID does not have a separate `ImageSurface` class. Use `cairo.surface.Surface` with `imageSurfaceCreate()` from `cairo.global`: + +```d +// GtkD +import cairo.ImageSurface; +ImageSurface surface = new ImageSurface(Format.ARGB32, width, height); + +// GID +import cairo.surface : Surface; +import cairo.global : imageSurfaceCreate; +Surface surface = imageSurfaceCreate(Format.Argb32, width, height); +``` + +#### GIO Application vs GTK Application +When using both, use aliases to avoid conflicts: + +```d +// GID +import gio.application : GioApplication = Application; +import gtk.application : Application; +``` + +#### GIO Settings vs GTK Settings +```d +// GID +import gio.settings : GSettings = Settings; +import gtk.settings : GtkSettings = Settings; +``` + +#### Global Functions +Many utility functions moved to `global` modules: + +```d +// GtkD +import glib.Util; +import glib.FileUtils; +import gtk.Main; +import gtk.Version; + +// GID +import glib.global : getCurrentDir, getHomeDir, setPrgname, chdir; +import gtk.global : checkVersion, getMajorVersion, getMinorVersion, getMicroVersion; +``` + +#### Internationalization +```d +// GtkD +import glib.Internationalization; +Internationalization.dgettext(domain, text); + +// GID +import glib.global : dgettext, dpgettext2; +dgettext(domain, text); +``` + +--- + +## 2. Signal Connections + +### Basic Pattern + +GtkD uses `addOn*` methods, GID uses `connect*` methods: + +| GtkD | GID | +|------|-----| +| `widget.addOnClicked(&handler)` | `widget.connectClicked(&handler)` | +| `widget.addOnDestroy(&handler)` | `widget.connectDestroy(&handler)` | +| `widget.addOnActivate(&handler)` | `widget.connectActivate(&handler)` | +| `widget.addOnStartup(&handler)` | `widget.connectStartup(&handler)` | +| `widget.addOnShutdown(&handler)` | `widget.connectShutdown(&handler)` | +| `widget.addOnCommandLine(&handler)` | `widget.connectCommandLine(&handler)` | +| `widget.addOnResponse(&handler)` | `widget.connectResponse(&handler)` | +| `widget.addOnClose(&handler)` | `widget.connectClose(&handler)` | + +### Signal Connection Return Value + +GID `connect*` methods return `ulong` (the signal handler ID) which can be used to disconnect later. + +### Settings Changed Signal + +```d +// GtkD +gsettings.addOnChanged(delegate(string key, Settings) { ... }); + +// GID - note the detail parameter (can be null for all keys) +gsettings.connectChanged(null, delegate(string key, GSettings) { ... }); +``` + +### Notify Signal (Property Changes) + +```d +// GtkD +settings.addOnNotify(&handler, "property-name", ConnectFlags.AFTER); + +// GID +settings.connectNotify("property-name", &handler, No.After); +``` + +### ConnectFlags + +```d +// GtkD +ConnectFlags.AFTER + +// GID +import gid.gid : No, Yes; +No.After // or Yes.After +``` + +--- + +## 3. Enum Naming Conventions + +GID uses PascalCase for enum values instead of SCREAMING_CASE: + +| GtkD | GID | +|------|-----| +| `ResponseType.OK` | `ResponseType.Ok` | +| `ResponseType.CANCEL` | `ResponseType.Cancel` | +| `ResponseType.DELETE_EVENT` | `ResponseType.DeleteEvent` | +| `DialogFlags.MODAL` | `DialogFlags.Modal` | +| `MessageType.ERROR` | `MessageType.Error` | +| `MessageType.WARNING` | `MessageType.Warning` | +| `ButtonsType.OK` | `ButtonsType.Ok` | +| `ButtonsType.OK_CANCEL` | `ButtonsType.OkCancel` | +| `IconSize.DIALOG` | `IconSize.Dialog` | +| `ApplicationFlags.HANDLES_COMMAND_LINE` | `ApplicationFlags.HandlesCommandLine` | +| `ApplicationFlags.NON_UNIQUE` | `ApplicationFlags.NonUnique` | +| `GOptionFlags.NONE` | `GOptionFlags.None` | +| `GOptionFlags.HIDDEN` | `GOptionFlags.Hidden` | +| `GOptionArg.STRING` | `GOptionArg.String` | +| `GOptionArg.STRING_ARRAY` | `GOptionArg.StringArray` | +| `GOptionArg.NONE` | `GOptionArg.None` | +| `Format.ARGB32` | `Format.Argb32` | +| `Operator.SOURCE` | `Operator.Source` | + +--- + +## 4. Constructor Patterns + +### Factory Methods Instead of Constructors + +GID often uses factory methods instead of constructors: + +```d +// GtkD +new Button("label") +new CheckButton("label") +new Image(iconName, size) +new SpinButton(min, max, step) +new Label("text") + +// GID +Button.newWithLabel("label") +CheckButton.newWithLabel("label") +Image.newFromIconName(iconName, size) +SpinButton.newWithRange(min, max, step) +new Label("text") // simple constructors still work +``` + +### Pixbuf Loading + +```d +// GtkD +new Pixbuf(filename) +new Pixbuf(filename, width, height, preserveAspect) + +// GID +Pixbuf.newFromFile(filename) +Pixbuf.newFromFileAtScale(filename, width, height, preserveAspect) +``` + +### AboutDialog + +```d +// GtkD +with (dialog = new AboutDialog()) { ... } + +// GID - need to separate construction from with block +dialog = new AboutDialog(); +with (dialog) { ... } +``` + +--- + +## 5. Property Access + +### GTK Settings Properties + +GID provides D-style property accessors: + +```d +// GtkD +Settings.getDefault().setProperty(GTK_APP_PREFER_DARK_THEME, darkMode); +Settings.getDefault().getProperty(GTK_MENU_BAR_ACCEL, value); + +// GID +GtkSettings.getDefault().gtkApplicationPreferDarkTheme = darkMode; +string accel = GtkSettings.getDefault().gtkMenuBarAccel; +GtkSettings.getDefault().gtkMenuBarAccel = ""; +GtkSettings.getDefault().gtkEnableAccels = true; +``` + +### Reset Property + +```d +// GtkD +Settings.getDefault.resetProperty(propertyName); + +// GID +GtkSettings.getDefault.resetProperty(propertyName); +``` + +--- + +## 6. C API Fallback Patterns + +Some widgets don't have high-level D constructors in GID and require using the C API directly. + +### MessageDialog + +```d +// GtkD +MessageDialog dialog = new MessageDialog(parent, DialogFlags.MODAL, + MessageType.ERROR, ButtonsType.OK, message, null); + +// GID +import gtk.c.functions : gtk_message_dialog_new; +import gtk.c.types : GtkDialogFlags, GtkMessageType, GtkButtonsType, GtkWidget, GtkWindow; +import gobject.object : ObjectG; +import gid.gid : No; + +GtkDialogFlags flags = GtkDialogFlags.Modal; +GtkWidget* widget = gtk_message_dialog_new( + parent ? cast(GtkWindow*) parent.cPtr(No.Dup) : null, + flags, + GtkMessageType.Error, + GtkButtonsType.Ok, + message.ptr, + null +); +MessageDialog dialog = ObjectG.getDObject!MessageDialog(cast(void*) widget, No.Take); +``` + +### Accessing C Pointers + +```d +// GtkD +widget.getWidgetStruct() +window.getWindowStruct() + +// GID +widget.cPtr(No.Dup) +// For specific types, cast as needed: +cast(GtkWindow*) window.cPtr(No.Dup) +``` + +### gtk_application_set_accels_for_action + +```d +// GtkD +gtk_application_set_accels_for_action(gtkApplication, Str.toStringz(actionName), tmp); + +// GID +import gid.gid : Str = ZeroTermString; +gtk_application_set_accels_for_action(cast(GtkApplication*)cPtr(No.Dup), Str(actionName), tmp); +``` + +--- + +## 7. Type System Differences + +### Variant.getString + +```d +// GtkD +size_t length; +string value = variant.getString(length); + +// GID - simplified, no length parameter needed +string value = variant.getString(); +``` + +### ListG to Array + +```d +// GtkD +ListG list = getWindows(); +Window[] windows = list.toArray!(Window)(); + +// GID - returns D array directly +Window[] windows = getWindows(); +``` + +### Application ID Validation + +```d +// GtkD +if (idIsValid(id)) { ... } + +// GID - static method on Application class +if (GioApplication.idIsValid(id)) { ... } +``` + +### Version Checking + +```d +// GtkD +if (Version.checkVersion(3, 19, 0).length == 0) { ... } + +// GID - returns null if version is sufficient +if (checkVersion(3, 19, 0) is null) { ... } +``` + +--- + +## 8. Common Problems and Solutions + +### Problem: "unable to read module" Error + +**Cause**: GtkD-style PascalCase import path used instead of GID snake_case. + +**Solution**: Convert import paths to snake_case: +```d +// Wrong +import gtk.ApplicationWindow; +import gio.SimpleAction; + +// Correct +import gtk.application_window; +import gio.simple_action; +``` + +### Problem: Unused Import Causes Build Failure + +**Cause**: An import references a non-existent module (leftover from incomplete migration). + +**Solution**: Remove unused imports. For example: +```d +// This was unused and the module doesn't exist in GID +import gobject.type : Type; // Remove this line +``` + +### Problem: Enum Value Not Found + +**Cause**: Using SCREAMING_CASE instead of PascalCase. + +**Solution**: Convert enum values: +```d +// Wrong +ResponseType.OK +DialogFlags.MODAL + +// Correct +ResponseType.Ok +DialogFlags.Modal +``` + +### Problem: setMarginLeft/setMarginRight Deprecated + +**Solution**: Use setMarginStart/setMarginEnd: +```d +// Deprecated +widget.setMarginLeft(0); +widget.setMarginRight(0); + +// Correct +widget.setMarginStart(0); +widget.setMarginEnd(0); +``` + +### Problem: Dynamic Symbol Loading (dlopen/dlsym) + +For runtime symbol loading (e.g., X11-specific functions), use POSIX APIs: + +```d +import core.sys.posix.dlfcn : dlopen, dlsym, RTLD_NOW; + +void* lib = dlopen("libgdk-3.so.0", RTLD_NOW); +if (lib !is null) { + auto func = cast(FuncType) dlsym(lib, "function_name"); +} +``` + +--- + +## 9. Memory Management + +### Ownership Flags + +GID uses `Flag!"Take"` for ownership: + +```d +import gid.gid : No, Yes; + +// Don't take ownership (caller still owns the object) +ObjectG.getDObject!Widget(ptr, No.Take); + +// Take ownership (GID will free when D object is collected) +ObjectG.getDObject!Widget(ptr, Yes.Take); +``` + +### Scope Exit for Cleanup + +```d +MessageDialog dialog = ...; +scope (exit) { + dialog.destroy(); +} +// use dialog... +``` + +--- + +## 10. Platform-Specific Considerations + +### X11 Functions + +X11-specific GDK functions are not directly available in GID and must be loaded at runtime: + +```d +// Load X11-specific functions dynamically +import core.sys.posix.dlfcn : dlopen, dlsym, RTLD_NOW; + +private void* gdkX11Lib; +private extern(C) ulong function(void*) gdk_x11_window_get_xid; + +static this() { + gdkX11Lib = dlopen("libgdk-3.so.0", RTLD_NOW); + if (gdkX11Lib !is null) { + gdk_x11_window_get_xid = cast(typeof(gdk_x11_window_get_xid)) + dlsym(gdkX11Lib, "gdk_x11_window_get_xid"); + } +} +``` + +### Idle and Timeout Functions + +```d +// GtkD +import gdk.Threads : threadsAddIdle, threadsAddTimeout; + +// GID +import gdk.global : threadsAddIdle, threadsAddTimeout; +import glib.types : SourceFunc, PRIORITY_DEFAULT_IDLE; + +// GID supports D delegates directly +SourceFunc wrappedDelegate = delegate bool() { ... }; +threadsAddIdle(PRIORITY_DEFAULT_IDLE, wrappedDelegate); +``` + +--- + +## Appendix: Import Mapping Quick Reference + +### GtkD Low-Level Modules → GID + +| GtkD | GID | +|------|-----| +| `gtkc.gtk` | Remove (use specific modules) | +| `gtkc.glib` | `glib.c.functions` | +| `gtkc.glibtypes` | `glib.c.types` | +| `gtkc.gobject` | `gobject.c.functions` | +| `gtkc.giotypes` | `gio.c.types` | +| `gtkc.Loader` | `core.sys.posix.dlfcn` | +| `gtkc.paths` | Remove (use dlopen directly) | +| `glib.Str` | `gid.gid : Str = ZeroTermString` or direct D strings | + +### Commonly Used GID Helper Imports + +```d +import gid.gid : No, Yes; // Ownership flags +import gid.gid : Str = ZeroTermString; // C string conversion +import gobject.object : ObjectG = ObjectWrap; // For getDObject +``` + +--- + +## 11. Signal Handler Block/Unblock + +### GtkD Pattern +```d +import gobject.Signals; +Signals.handlerBlock(widget, handlerId); +Signals.handlerUnblock(widget, handlerId); +``` + +### GID Pattern +```d +import gobject.global : signalHandlerBlock, signalHandlerUnblock; +signalHandlerBlock(widget, handlerId); +signalHandlerUnblock(widget, handlerId); +``` + +--- + +## 12. GDK Key Constants (Keysyms) + +GID does not provide a `gdk.keysyms` module. Key constants must be defined locally: + +```d +// GtkD +import gdk.Keysyms; +if (keyval == GdkKeysyms.GDK_Escape) { ... } + +// GID - define locally +enum GdkKeysyms { + GDK_Escape = 0xff1b, + GDK_Return = 0xff0d, + GDK_Tab = 0xff09, + GDK_BackSpace = 0xff08, + GDK_Delete = 0xffff, + GDK_Home = 0xff50, + GDK_End = 0xff57, + GDK_Page_Up = 0xff55, + GDK_Page_Down = 0xff56, + GDK_Up = 0xff52, + GDK_Down = 0xff54, + GDK_Left = 0xff51, + GDK_Right = 0xff53, +} +``` + +--- + +## 13. Event Methods + +### Getting Event Properties + +```d +// GtkD +ScrollDirection direction; +event.getScrollDirection(direction); + +uint keyval; +event.getKeyval(keyval); + +// GID - direct return values +ScrollDirection direction = event.getScrollDirection(); +uint keyval = event.getKeyval(); +uint button = event.getButton(); +GdkWindowState newState = event.getNewWindowState(); +``` + +--- + +## 14. FileChooserDialog + +GID doesn't have a high-level constructor for FileChooserDialog. Use C API: + +```d +// GtkD +FileChooserDialog fcd = new FileChooserDialog( + _("Open File"), + parent, + FileChooserAction.OPEN, + [_("Open"), _("Cancel")]); + +// GID +import gtk.c.functions : gtk_file_chooser_dialog_new; +import gtk.c.types : GtkFileChooserAction, GtkWidget, GtkWindow; + +GtkWidget* widget = gtk_file_chooser_dialog_new( + _("Open File").ptr, + cast(GtkWindow*) parent.cPtr(No.Dup), + GtkFileChooserAction.Open, + _("_Cancel").ptr, ResponseType.Cancel, + _("_Open").ptr, ResponseType.Accept, + null +); +FileChooserDialog fcd = ObjectG.getDObject!FileChooserDialog(cast(void*) widget, No.Take); +``` + +--- + +## 15. Window Comparison + +```d +// GtkD +if (window.getWindowStruct() == other.getWindowStruct()) { ... } + +// GID +if (window.cPtr(No.Dup) == other.cPtr(No.Dup)) { ... } +``` + +--- + +## 16. List Toplevels + +```d +// GtkD +ListG list = window.listToplevels(); +Window[] windows = list.toArray!(Window)(); + +// GID - returns D array directly +Window[] windows = window.listToplevels(); +``` + +--- + +## 17. Pango Types + +```d +// GtkD +import gtk.PgFontDescription; +label.setEllipsize(PangoEllipsizeMode.START); + +// GID +import pango.types : EllipsizeMode; +label.setEllipsize(EllipsizeMode.Start); +``` + +--- + +## 18. Cairo Types for Drawing + +```d +// GtkD +import cairo.Context; +cr.selectFontFace("monospace", cairo_font_slant_t.NORMAL, cairo_font_weight_t.NORMAL); +cairo_text_extents_t extents; +cr.textExtents(text, &extents); + +// GID +import cairo.context : Context; +import cairo.types : FontSlant, FontWeight, TextExtents; +cr.selectFontFace("Sans", FontSlant.Normal, FontWeight.Bold); +TextExtents extents; +cr.textExtents(text, extents); +``` + +--- + +## 19. Secret Service API (libsecret) + +### Schema Creation + +GID doesn't expose a high-level Schema constructor. Use C API: + +```d +// GtkD +import secret.Schema; +string[string] ht; +ht["id"] = ""; +ht["description"] = ""; +schema = new Schema("com.example.Password", SecretSchemaFlags.NONE, ht); + +// GID +import secret.schema : Schema; +import secret.c.types : SecretSchema, SecretSchemaAttributeType, SecretSchemaFlags; +import secret.c.functions : secret_schema_newv; +import glib.c.types : GHashTable; +import glib.c.functions : g_hash_table_new, g_hash_table_insert; +import std.string : toStringz; +import std.typecons : Flag, Yes; + +GHashTable* ht = g_hash_table_new(null, null); +g_hash_table_insert(ht, cast(void*) toStringz("id"), cast(void*) SecretSchemaAttributeType.String); +g_hash_table_insert(ht, cast(void*) toStringz("description"), cast(void*) SecretSchemaAttributeType.String); +SecretSchema* cSchema = secret_schema_newv(toStringz("com.example.Password"), SecretSchemaFlags.None, ht); +schema = new Schema(cast(void*) cSchema, Yes.Take); +``` + +### Async Callbacks + +GID async methods use D delegates instead of C function pointers with user data: + +```d +// GtkD (C-style callbacks with user data) +extern(C) static void secretServiceCallback(GObject* sourceObject, GAsyncResult* res, void* userData) { + PasswordDialog pd = cast(PasswordDialog) ObjectWrap.getDObject!(Dialog)(cast(GtkDialog*) userData, false); + // ... +} +Service.get(SecretServiceFlags.OPEN_SESSION, cancellable, &secretServiceCallback, this.getDialogStruct()); + +// GID (D delegates, no user data needed - captures context) +import gio.async_result : AsyncResult; +void onSecretServiceReady(ObjectWrap sourceObject, AsyncResult res) { + Service ss = Service.getFinish(res); + // Access `this` directly since delegate captures context +} +Service.get(ServiceFlags.OpenSession, cancellable, &onSecretServiceReady); +``` + +### Secret Service Enums + +```d +// GtkD +SecretSchemaFlags.NONE +SecretServiceFlags.OPEN_SESSION +SecretCollectionFlags.LOAD_ITEMS + +// GID +import secret.types : SchemaFlags, ServiceFlags, CollectionFlags; +SchemaFlags.None +ServiceFlags.OpenSession +CollectionFlags.LoadItems +``` + +--- + +## 20. ListStore and TreeView + +### ListStore Creation + +```d +// GtkD +ls = new ListStore([GType.STRING, GType.STRING]); + +// GID +import gx.gtk.util : GTypes; // Custom helper enum +ls = ListStore.new_([GTypes.STRING, GTypes.STRING]); +``` + +### Appending Rows + +```d +// GtkD +TreeIter iter = ls.createIter(); +ls.setValue(iter, 0, "value"); + +// GID +TreeIter iter; +ls.append(iter); // out parameter pattern +ls.setValue(iter, 0, new Value("value")); // wrap in Value +``` + +### Getting Selected TreeIter + +```d +// GtkD +TreeIter selected = treeView.getSelectedIter(); + +// GID - no method on TreeView, use helper function +TreeIter getSelectedIter(TreeView tv) { + TreeSelection selection = tv.getSelection(); + if (selection is null) return null; + TreeModel model; + TreeIter iter; + if (selection.getSelected(model, iter)) { + return iter; + } + return null; +} +TreeIter selected = getSelectedIter(treeView); +``` + +--- + +## 21. GDK Atoms and Clipboard + +### Atom Objects vs Raw Pointers + +```d +// GtkD (raw GdkAtom pointers) +private __gshared GdkAtom GDK_SELECTION_CLIPBOARD; +shared static this() { + auto clipboardAtom = Atom.intern("CLIPBOARD", false); + GDK_SELECTION_CLIPBOARD = cast(GdkAtom)clipboardAtom.getAtomStruct(); +} +Clipboard.get(GDK_SELECTION_CLIPBOARD); + +// GID (Atom objects) +import gdk.atom : Atom; +private __gshared Atom GDK_SELECTION_CLIPBOARD; +shared static this() { + GDK_SELECTION_CLIPBOARD = Atom.intern("CLIPBOARD", false); +} +Clipboard.get(GDK_SELECTION_CLIPBOARD); // accepts Atom directly +``` + +--- + +## 22. VTE Terminal + +### feedChild Method + +```d +// GtkD +vte.feedChild(text); + +// GID - requires ubyte[] not string +vte.feedChild(cast(ubyte[]) text); +``` + +### VTE Regex Creation + +```d +// GtkD +VRegex.newMatch(pattern, -1, flags) +VRegex.newSearch(pattern, -1, flags) + +// GID +VRegex.newForMatch(pattern, -1, flags) +VRegex.newForSearch(pattern, -1, flags) +``` + +### VTE Enums + +```d +// GtkD +VteCursorShape.BLOCK +VteCursorShape.IBEAM +VteCursorShape.UNDERLINE + +// GID +VteCursorShape.Block +VteCursorShape.Ibeam +VteCursorShape.Underline +``` + +--- + +## 23. File/URI Operations + +### Filename to/from URI + +```d +// GtkD +import glib.URI; +string uri = URI.filenameToUri(filename, null); +string filename = URI.filenameFromUri(uri, hostname); + +// GID +import glib.global : filenameToUri, filenameFromUri; +string uri = filenameToUri(filename, null); +string hostname; +string filename = filenameFromUri(uri, hostname); // out parameter +``` + +### Show URI + +```d +// GtkD +import gio.MountOperation; +MountOperation.showUri(null, uri, timestamp); + +// GID +import gtk.global : showUri, showUriOnWindow; +showUri(null, uri, cast(uint) timestamp); +// or with parent window: +showUriOnWindow(parentWindow, uri, cast(uint) timestamp); +``` + +--- + +## 24. GSpawn Flags + +```d +// GtkD +GSpawnFlags.SEARCH_PATH_FROM_ENVP +GSpawnFlags.FILE_AND_ARGV_ZERO +GSpawnFlags.SEARCH_PATH + +// GID +GSpawnFlags.SearchPathFromEnvp +GSpawnFlags.FileAndArgvZero +GSpawnFlags.SearchPath +``` + +--- + +## 25. GDK Modifier Types and Scroll Direction + +```d +// GtkD +ModifierType.CONTROL_MASK +ModifierType.SHIFT_MASK +ModifierType.MOD1_MASK +ScrollDirection.UP +ScrollDirection.DOWN +ScrollDirection.SMOOTH + +// GID +import gdk.c.types : GdkModifierType; +GdkModifierType.ControlMask +GdkModifierType.ShiftMask +GdkModifierType.Mod1Mask +ScrollDirection.Up +ScrollDirection.Down +ScrollDirection.Smooth +``` + +--- + +## 26. GTK State and Policy Types + +```d +// GtkD +StateFlags.ACTIVE +PolicyType.NEVER +PolicyType.AUTOMATIC + +// GID +StateFlags.Active +PolicyType.Never +PolicyType.Automatic +``` + +--- + +## 27. Cursor Types + +```d +// GtkD +CursorType.HAND2 + +// GID +import gdk.types : CursorType; +CursorType.Hand2 +``` + +--- + +## 28. Popover and Rectangle + +### Popover Creation from Menu Model + +```d +// GtkD +Popover popover = new Popover(widget, menuModel); + +// GID +Popover popover = Popover.newFromModel(widget, menuModel); +``` + +### setPointingTo with Rectangle + +```d +// GtkD +GdkRectangle rect = GdkRectangle(x, y, 1, 1); +popover.setPointingTo(&rect); + +// GID +import gdk.rectangle : Rectangle; +// Need to create Rectangle object, not use GdkRectangle pointer +Rectangle rect = new Rectangle(x, y, 1, 1); +popover.setPointingTo(rect); +``` + +--- + +## 29. Frame Constructor + +```d +// GtkD +Frame frame = new Frame(childWidget, null); + +// GID - no child parameter in constructor +Frame frame = new Frame(null); // label parameter only +frame.add(childWidget); +``` + +--- + +## 30. Image Creation + +```d +// GtkD +Image img = new Image("icon-name", IconSize.Menu); + +// GID +Image img = Image.newFromIconName("icon-name", IconSize.Menu); +``` + +--- + +## 31. Exception Types + +```d +// GtkD +try { ... } +catch (GException e) { ... } + +// GID +import glib.error : ErrorWrap; +try { ... } +catch (ErrorWrap e) { ... } +``` + +--- + +## 32. GSourceFunc Type + +```d +// GtkD +import glib.Timeout; +Timeout.add(interval, delegate bool() { ... }); + +// GID +import glib.c.types : GSourceFunc; +import glib.c.functions : g_timeout_add; +// For C API callbacks, need extern(C) function or use delegate wrapper +``` + +--- + +## 33. DBusConnection and Signal Subscribe + +### GID DBusConnection +```d +// GtkD +import gio.DBusConnection; +DBusConnection connection = new DBusConnection(address, flags, null, null); +connection.signalSubscribe(sender, iface, member, path, null, + GDBusSignalFlags.NONE, cast(GDBusSignalCallback)&callback, userData, null); + +// GID +import gio.dbus_connection : DBusConnection; +import gio.types : DBusConnectionFlags, DBusSignalFlags, DBusCallFlags; + +// Use factory method instead of constructor +DBusConnection connection = DBusConnection.newForAddressSync( + address, + DBusConnectionFlags.AuthenticationClient | DBusConnectionFlags.MessageBusConnection, + null, null); + +// Use D delegate instead of C callback +connection.signalSubscribe( + sender, iface, member, path, null, + DBusSignalFlags.None, + (DBusConnection conn, string senderName, string objectPath, + string interfaceName, string signalName, GVariant parameters) { + // Handle signal + }); +``` + +--- + +## 34. GVariant Construction + +### Dict Entries +```d +// GtkD - could use nested constructor +new GVariant(new GVariant(key), new GVariant(value)); + +// GID - use factory method +import glib.variant : Variant; +auto keyVar = new Variant(key); +auto valVar = new Variant(value); +auto dictEntry = Variant.newDictEntry(keyVar, valVar); +``` + +### Using C API for Complex Variants +```d +// For complex variant patterns not supported by GID wrappers: +import glib.c.functions : g_variant_new; +import glib.c.types : GVariant_ = GVariant; + +GVariant_* vs = g_variant_new("(^ay^aay@a{uh}@a{ss}u)", + workingDir, args, + cast(GVariant_*)fdVar._cPtr(), + cast(GVariant_*)envVar._cPtr(), + flags); + +auto result = new Variant(cast(void*)vs, Yes.Take); +``` + +--- + +## 35. DragContext - listTargets + +The `listTargets()` method is not wrapped in GID. Use the C API: +```d +// GID - access C API directly +import gdk.c.functions : gdk_drag_context_list_targets; +import gdk.c.types : GdkDragContext; +import glib.c.types : GList; + +auto targetsList = gdk_drag_context_list_targets(cast(GdkDragContext*)dc._cPtr); +for (auto l = targetsList; l !is null; l = l.next) { + auto targetAtom = new Atom(l.data, No.Take); + if (targetAtom.name() == targetName) { + // Found it + } +} +``` + +--- + +## 36. Atom Methods + +```d +// GtkD +import gdk.atom : intern, name; +GdkAtom atom = intern("text/plain", false); +string atomName = name(atom); + +// GID - use Atom class methods +import gdk.atom : Atom; +Atom atom = Atom.intern("text/plain", false); +string atomName = atom.name(); +``` + +--- + +## 37. SelectionData + +### getData vs getDataWithLength +```d +// GtkD +char[] data = selectionData.getDataWithLength(); + +// GID - use getData which returns ubyte[] +ubyte[] rawData = selectionData.getData(); +char[] data = cast(char[])rawData; +``` + +### Setting Selection Data +```d +// GtkD +data.set(intern(atomName, false), 8, buffer); + +// GID +data.set(Atom.intern(atomName, false), 8, cast(ubyte[])buffer); +``` + +--- + +## 38. Cairo Operator Enum + +```d +// GtkD +import cairo.c.types : cairo_operator_t; +cr.setOperator(cairo_operator_t.SOURCE); + +// GID +import cairo.types : Operator; +cr.setOperator(Operator.Source); +``` + +--- + +## 39. Pango Scale and Types + +```d +// GtkD +import pango.PgLayout; +pgl.setWidth(width * PANGO_SCALE); +pgl.setWrap(PangoWrapMode.WORD_CHAR); +pgl.setAlignment(PangoAlignment.RIGHT); + +// GID +import pango.types : SCALE, WrapMode, Alignment; +pgl.setWidth(width * SCALE); +pgl.setWrap(WrapMode.WordChar); +pgl.setAlignment(Alignment.Right); +``` + +--- + +## 40. PangoCairo Functions + +```d +// GtkD +import pango.PgCairo; +PgCairo.showLayout(cr, layout); + +// GID +import pangocairo.global : showLayout; +showLayout(cr, layout); +``` + +--- + +## 41. VTE spawnSync + +```d +// GtkD +vte.spawnSync(flags, workingDir, args, envv, spawnFlags, null, null, gpid, null); + +// GID - childPid is an out parameter, not a pointer +int childPid; +bool result = vte.spawnSync(PtyFlags.Default, workingDir, args, envv, + spawnFlags, null, childPid, null); +gpid = childPid; +``` + +--- + +## 42. VTE Version Functions + +```d +// GtkD +import VteVersion = vte.Version; +VteVersion.Version.getMinorVersion(); + +// GID +import vte.global : getMinorVersion, getMicroVersion; +getMinorVersion(); +``` + +--- + +## 43. InfoBar Constructor + +```d +// GtkD +super([_("Relaunch")], [ResponseType.Ok]); + +// GID - no convenience constructor, add buttons manually +super(); +addButton(_("Relaunch"), ResponseType.Ok); +``` + +--- + +## 44. MessageDialog Creation + +GID doesn't have a convenience constructor for MessageDialog. Use C API: +```d +// GID +import gtk.c.functions : gtk_message_dialog_new; +import gtk.c.types : GtkWindow, GtkDialogFlags, GtkMessageType, GtkButtonsType; + +auto ptr = gtk_message_dialog_new( + parent ? cast(GtkWindow*)parent._cPtr() : null, + cast(GtkDialogFlags)(DialogFlags.Modal), + cast(GtkMessageType)(MessageType.Warning), + cast(GtkButtonsType)(ButtonsType.None), + null); +super(cast(void*)ptr, Yes.Take); +``` + +--- + +## 45. GMarkup Parse Context + +For XML parsing with GMarkup, import from GID's C bindings: +```d +// GID +import glib.c.types : GMarkupParser, GMarkupParseContext, GMarkupParseFlags, + GError, GDestroyNotify; +import glib.c.functions : g_markup_parse_context_new, g_markup_parse_context_free, + g_markup_parse_context_parse, g_markup_parse_context_end_parse, + g_error_free; + +// Functions return bool, not int +bool result = g_markup_parse_context_parse(context, text.ptr, textLen, &error); +``` + +--- + +## 46. EventButton to Event Conversion + +When APIs require a generic `Event` but you have a specific event type like `EventButton`: + +```d +// GID - create Event wrapper from EventButton +import gdk.event : Event; +import gdk.event_button : EventButton; +import gid.gid : No; + +bool onButtonPress(EventButton event, Widget widget) { + // For APIs that need generic Event (like vte.matchCheckEvent) + auto genericEvent = new Event(event._cPtr(), No.Take); + + // Now use genericEvent with APIs that expect Event + match = vte.matchCheckEvent(genericEvent, tag); + + // Access EventButton properties directly (not through methods) + uint buttonNum = event.button; // not event.button() or event.getButton() + ModifierType state = event.state; // not event.getState() + double x = event.x; + double y = event.y; + EventType type = event.type; // not event.getEventType() + + return false; +} +``` + +--- + +## 47. GList Iteration (C API) + +When using C API functions that return `GList*`: + +```d +// GID - iterate through C GList +import glib.c.types : GList; +import gid.gid : No; + +// Example: gdk_drag_context_list_targets returns GList* +auto glist = gdk_drag_context_list_targets(cast(GdkDragContext*)dc._cPtr); + +for (auto l = glist; l !is null; l = l.next) { + // Wrap the data in the appropriate GID class + auto atom = new Atom(l.data, No.Take); + string name = atom.name(); + // ... process item +} + +// Note: Don't free the list if it's owned by the object (check API docs) +``` + +--- + +## 48. KeyFile Usage + +```d +// GtkD +import glib.KeyFile; +KeyFile kf = new KeyFile(); +kf.loadFromFile(filename, GKeyFileFlags.NONE); +string value = kf.getString("Group", "key"); + +// GID +import glib.key_file : KeyFile; +import glib.types : KeyFileFlags; + +KeyFile kf = new KeyFile(); +kf.loadFromFile(filename, KeyFileFlags.None); +string value = kf.getString("Group", "key"); +``` + +--- + +## 49. Container Casting for Widget Methods + +Some methods return `Widget` but you need `Container` methods like `add()`: + +```d +// GtkD +dialog.getMessageArea().add(widget); + +// GID - getMessageArea returns Widget, need to cast to Container +import gtk.container : Container; + +(cast(Container)dialog.getMessageArea()).add(widget); + +// Or use a local variable for clarity +auto msgArea = cast(Container)dialog.getMessageArea(); +msgArea.add(widget); +``` + +--- + +## 50. Out Parameters vs Return Values + +Some GID functions use `out` parameters instead of return values: + +```d +// GtkD - some functions return values +int pid = vte.spawnSync(...); + +// GID - pid is an out parameter +int childPid; +bool success = vte.spawnSync(PtyFlags.Default, workingDir, args, envv, + spawnFlags, null, childPid, null); // childPid is out parameter +gpid = childPid; + +// Same pattern for other out parameters +int width, height; +widget.getSize(width, height); // width and height are out parameters +``` + +--- + +## 51. GVariant Handle Creation + +For file descriptor handles in GVariant: + +```d +// GID +import glib.c.functions : g_variant_new_handle; +import glib.variant : Variant; + +// Create a handle variant for a file descriptor +auto handleVar = new Variant(g_variant_new_handle(fd), true); + +// Use in dict entry +auto keyVar = new Variant(cast(uint)index); +auto dictEntry = Variant.newDictEntry(keyVar, handleVar); +``` + +--- + +## 52. Flag Enum Combining + +GID uses proper D enums that support bitwise operations: + +```d +// GtkD +GDBusConnectionFlags.AUTHENTICATION_CLIENT | GDBusConnectionFlags.MESSAGE_BUS_CONNECTION + +// GID - PascalCase enum values +import gio.types : DBusConnectionFlags; +DBusConnectionFlags.AuthenticationClient | DBusConnectionFlags.MessageBusConnection + +// For modifier keys +import gdk.types : ModifierType; +if (state & ModifierType.ControlMask) { ... } +if (state & (ModifierType.ShiftMask | ModifierType.ControlMask)) { ... } +``` + +--- + +## 53. GID 0.9.7 Bug: Settings.getStrv() Returns Only 1 Element + +**Bug**: GID 0.9.7's `Settings.getStrv()` has a bug in the loop that counts array length - it contains an erroneous `break` statement that causes it to return at most 1 element instead of all elements. + +**Impact**: Any code retrieving string arrays from GSettings (like color palettes with 16 colors) will only get the first element. + +**Workaround**: Create a custom function that correctly retrieves all elements: + +```d +// In gx/gtk/util.d +import gio.settings : Settings; +import gio.c.functions : g_settings_get_strv; +import gio.c.types : GSettings; +import gid.gid : No; + +string[] getSettingsStrv(Settings settings, string key) { + import std.string : fromStringz; + + char** cretval = g_settings_get_strv(cast(GSettings*)settings._cPtr(No.Dup), key.ptr); + string[] result; + + if (cretval !is null) { + // Correctly count all elements (no erroneous break) + size_t length = 0; + while (cretval[length] !is null) { + length++; + } + + result = new string[length]; + foreach (i; 0 .. length) { + result[i] = cast(string) fromStringz(cretval[i]); + } + } + + return result; +} + +// Usage +string[] colors = getSettingsStrv(gsProfile, "palette"); // Returns all 16 colors +``` + +--- + +## 54. GID Bug: VTE Terminal.setColors() Palette Array + +**Bug**: GID's `vte.terminal.setColors()` doesn't correctly pass the RGBA palette array to the C function. The binding uses `obj._cPtr` (getting a delegate) instead of `obj._cPtr()` (calling the method to get the pointer). + +**Impact**: Terminal palette colors appear all black because the C function receives garbage data. + +**Workaround**: Create a custom function that correctly builds the GdkRGBA array: + +```d +// In gx/gtk/vte.d +import vte.terminal : Terminal; +import vte.c.functions : vte_terminal_set_colors; +import vte.c.types : VteTerminal, GdkRGBA; +import gdk.rgba : RGBA; +import gid.gid : No; + +void setTerminalColors(Terminal terminal, RGBA foreground, RGBA background, RGBA[] palette) { + // Build palette array correctly + GdkRGBA[] paletteArray; + if (palette !is null) { + paletteArray = new GdkRGBA[palette.length]; + foreach (i, rgba; palette) { + if (rgba !is null) { + paletteArray[i] = *cast(GdkRGBA*)rgba._cPtr(No.Dup); + } + } + } + + // Call VTE C function directly + vte_terminal_set_colors( + cast(VteTerminal*)terminal._cPtr(No.Dup), + foreground ? cast(const(GdkRGBA)*)foreground._cPtr(No.Dup) : null, + background ? cast(const(GdkRGBA)*)background._cPtr(No.Dup) : null, + paletteArray.length > 0 ? paletteArray.ptr : null, + paletteArray.length + ); +} + +// Usage +setTerminalColors(vte, vteFG, vteBG, vtePalette); +``` + +--- + +## 55. Editable to Entry Cast Doesn't Work in GID + +**Problem**: In GtkD, you could cast the `Editable` parameter in a signal handler back to `Entry`. In GID, this cast fails. + +```d +// GtkD - worked +Entry eName = new Entry(); +eName.connectChanged(delegate(Editable editable) { + Entry entry = cast(Entry) cast(void*) editable; // Works in GtkD + string text = entry.getText(); +}); + +// GID - FAILS (entry will be null or crash) +Entry eName = new Entry(); +eName.connectChanged(delegate(Editable editable) { + Entry entry = cast(Entry) cast(void*) editable; // DOESN'T WORK + string text = entry.getText(); // Crash! +}); +``` + +**Solution**: Capture the Entry variable from the enclosing scope instead of casting: + +```d +// GID - correct approach +Entry eName = new Entry(); +eName.connectChanged(delegate(Editable editable) { + // Use eName directly from closure - don't cast the Editable + string text = eName.getText(); + onNameChanged(text); +}); +``` + +--- + +## 56. Static Array Slice Required for setStrv + +**Problem**: When passing a static array (e.g., `string[16]`) to `setStrv()`, you must explicitly slice it. + +```d +// GID - WRONG (may not compile or pass wrong data) +string[16] palette; +// ... fill palette ... +gsProfile.setStrv("palette-key", palette); // Static array + +// GID - CORRECT +string[16] palette; +// ... fill palette ... +gsProfile.setStrv("palette-key", palette[]); // Explicit slice to dynamic array +``` + +--- + +## 57. Stateful Actions: Initial State in Constructor + +**Problem**: In GID, stateful actions should have their initial state passed in the registration call, not set separately with `setState()`. + +```d +// GtkD approach (also works in GID but less clean) +saViewSideBar = registerAction(actionMap, "win", "sidebar", ...); +saViewSideBar.setState(new GVariant(false)); + +// GID - preferred approach: pass initial state in registration +saViewSideBar = registerActionWithSettings(actionMap, "win", "sidebar", gsShortcuts, + delegate(Variant value, SimpleAction sa) { + bool newState = !sa.getState().getBoolean(); + sa.setState(new GVariant(newState)); + // ... handle state change + }, + null, // parameterType + new GVariant(false)); // initial state +``` + +--- + +## 58. Null Event Checks in Signal Handlers + +**Problem**: In GID, event signal handlers may receive null events in some edge cases. Always check for null before accessing event properties. + +```d +// GID - WRONG (may crash) +vte.connectKeyPressEvent(delegate(EventKey event) { + uint keyval = event.keyval; // Crash if event is null! + return false; +}); + +// GID - CORRECT +vte.connectKeyPressEvent(delegate(EventKey event) { + if (event is null) return false; // Null check first + uint keyval = event.keyval; + return false; +}); + +// Same for other event types +connectButtonPressEvent(delegate(EventButton event, Widget widget) { + if (event is null) return false; + // ... safe to access event properties +}); + +connectWindowStateEvent(delegate(EventWindowState event, Widget w) { + if (event is null) return false; + WindowState newState = event.newWindowState; + // ... +}); +``` + +--- + +## 59. IconTheme.addResourcePath for GResource Icons + +**Problem**: Custom icons bundled in a GResource file are not automatically discoverable by GTK's IconTheme. + +**Solution**: After registering the GResource, add its icon path to the default IconTheme: + +```d +import gtk.icon_theme : IconTheme; +import gx.gtk.resource : findResource; + +// Register the gresource file +if (findResource("myapp/resources/myapp.gresource", true)) { + // Register the gresource icon path with the icon theme + IconTheme iconTheme = IconTheme.getDefault(); + if (iconTheme !is null) { + iconTheme.addResourcePath("/com/myapp/icons"); + trace("Added icon resource path: /com/myapp/icons"); + } +} +``` + +**Note**: The path passed to `addResourcePath()` is the resource path inside the gresource, not a filesystem path. + +--- + +## 60. Resource Loading: Search User Data Directory + +**Problem**: GID's resource loading may only search system data directories, missing user-local resources. + +**Solution**: When implementing resource finding, search user data directory first: + +```d +import glib.global : getSystemDataDirs, getUserDataDir; + +Resource findResource(string resourcePath, bool register = true) { + // Search in user data dir first, then system data dirs + string[] searchPaths = [getUserDataDir()] ~ getSystemDataDirs(); + foreach (path; searchPaths) { + auto fullpath = buildPath(path, resourcePath); + if (exists(fullpath)) { + Resource resource = Resource.load(fullpath); + if (register && resource) { + resourcesRegister(resource); + } + return resource; + } + } + return null; +} +``` + +This allows users to override system resources by placing files in `~/.local/share/`. + +--- + +## 61. StyleContext Color Functions: Use ref Not out + +**Problem**: When wrapping StyleContext color retrieval functions, using `out RGBA color` parameter resets the RGBA object to null before the function can fill it. + +```d +// WRONG - out parameter resets color to null +void getStyleBackgroundColor(StyleContext context, StateFlags flags, out RGBA color) { + // color is null here due to 'out' semantics! + context.getBackgroundColor(flags, color); // Crash or no-op +} + +// CORRECT - ref parameter preserves the RGBA object +void getStyleBackgroundColor(StyleContext context, StateFlags flags, ref RGBA color) { + with (context) { + save(); + setState(flags); + getBackgroundColor(getState(), color); // color is valid + restore(); + } +} +``` + +**Note**: In D, `out` parameters are reset to their `.init` value (null for class references) at function entry, while `ref` parameters preserve their incoming value. + +--- + +## 62. Keyboard Shortcuts: Use registerActionWithSettings + +**Problem**: Actions that need keyboard shortcuts from GSettings must use `registerActionWithSettings()`, not `registerAction()`. Using the wrong function will result in the shortcut not working even though it's defined in GSettings. + +```d +// WRONG - shortcut won't be picked up from GSettings +registerAction(this, "win", ACTION_WIN_FULLSCREEN, null, delegate(Variant value, SimpleAction sa) { + // F11 won't trigger this! + bool newState = !sa.getState().getBoolean(); + sa.setState(new GVariant(newState)); + if (newState) fullscreen(); + else unfullscreen(); +}, null, new GVariant(false)); + +// CORRECT - shortcut is picked up from GSettings +registerActionWithSettings(this, "win", ACTION_WIN_FULLSCREEN, gsShortcuts, delegate(Variant value, SimpleAction sa) { + // F11 now works! + bool newState = !sa.getState().getBoolean(); + sa.setState(new GVariant(newState)); + if (newState) fullscreen(); + else unfullscreen(); +}, null, new GVariant(false)); +``` + +**Note**: `registerActionWithSettings()` looks up the shortcut key in the GSettings object using the pattern `{prefix}-{actionName}` (e.g., `win-fullscreen`) and registers it with the application. Without this, you must manually call `app.setAccelsForAction()` to register shortcuts. diff --git a/README.md b/README.md index 39f46f948..f90627645 100644 --- a/README.md +++ b/README.md @@ -85,16 +85,18 @@ with translations, please do not submit direct pull requests to this repository ### Building -Tilix is written in [D](https://dlang.org/) and GTK 3 using the gtkd framework. This project uses dub to manage the build process including fetching the dependencies, +Tilix is written in [D](https://dlang.org/) and GTK 3 using the [gid](https://github.com/Kymorphia/gid) (GObject Introspection D) bindings. This project uses dub to manage the build process including fetching the dependencies, thus there is no need to install dependencies manually. The only thing you need to install to build the application is the D tools (compiler and Phobos) along with dub itself. -Note that D supports three [compilers](https://wiki.dlang.org/Compilers) (DMD, GDC and LDC) but Tilix only supports DMD and LDC. +Note that D supports three [compilers](https://wiki.dlang.org/Compilers) (DMD, GDC and LDC) but Tilix requires the GDC compiler for proper GObject introspection support. Once you have those installed, compiling the application is a one line command as follows: ``` -dub build --build=release +dub build --compiler=gdc --build=release ``` +You can also use the `dmd` or `ldc2` compilers if you prefer. Use `dmd` while developing and `gdc` or `ldc2` for release builds. + The application depends on various resources to function correctly, run `sudo ./install.sh` to build and copy all of the resources to the correct locations. Note this has only been tested on Arch Linux, use with caution. Note : `install.sh` will install Tilix to your `/usr` directory. If you are interested in installing Tilix to a custom location, you can specify the `PREFIX` as an @@ -107,9 +109,17 @@ for more information. #### Build Dependencies Tilix depends on the following libraries as defined in dub.json: -* [gtkd](http://gtkd.org/) >= 3.11.0 +* [gid](https://github.com/Kymorphia/gid) 0.9.7 or later (GObject Introspection D bindings for GTK3, VTE, and libsecret) * gdk-pixbuf-pixdata (Used when building resource file) +##### GID Package Requirements + +The gid bindings require the following system packages for GObject introspection: +* `gobject-introspection` - GObject introspection core +* `gtk3` - GTK+ 3 libraries and typelib files +* `vte291` or `vte3` - VTE terminal widget (version 0.46+) +* `libsecret` - Secret Service API library + ### Install Tilix Tilix is available as [packages](https://gnunn1.github.io/tilix-web/#packages) for a variety of distributions. diff --git a/data/gsettings/com.gexperts.Tilix.gschema.xml b/data/gsettings/com.gexperts.Tilix.gschema.xml index bcf4cff75..c050c210f 100644 --- a/data/gsettings/com.gexperts.Tilix.gschema.xml +++ b/data/gsettings/com.gexperts.Tilix.gschema.xml @@ -1,4 +1,4 @@ - + - - - + + + - - - - + + + + - - - - - + + + + + - - - - + + + + - - - - - + + + + + - - - + + + - - - + + + - - - + + + - - - - + + + + - - + + - - - - - + + + + + - - - + + + - - - - + + + + - - - + + + - - - - + + + + - - - - + + + + - - + + @@ -257,7 +257,8 @@ false Whether the standard GTK shortcut for menubar access is enabled - Normally you can access the menubar with F10. This can also be customized via gtkrc (gtk-menu-bar-accel = "whatever"). This option allows the standard menubar accelerator to be disabled. + Normally you can access the menubar with F10. This can also be customized via gtkrc (gtk-menu-bar-accel = "whatever"). This option allows the standard menubar accelerator to be disabled. @@ -514,12 +515,14 @@ 256 The maximum number of lines to check for trigger matches - When the terminal reports a block of text, this setting determines how many lines are checked for trigger matches starting with the last line. + When the terminal reports a block of text, this setting determines how many lines are checked for trigger matches starting with the last line. false Whether an unlimited number of lines should be processed for triggers - If true, all available lines will be processed for triggers. When outputing large amounts of text to the terminal this may impact performance. + If true, all available lines will be processed for triggers. When outputing large amounts of text to the terminal this may impact performance. @@ -547,9 +550,7 @@ - + ['2b7c4080-0ddd-46c5-8f23-563fd3ba789d'] '2b7c4080-0ddd-46c5-8f23-563fd3ba789d' @@ -666,12 +667,14 @@ '#000000' Cursor background color - Custom color of the background of the terminal's cursor, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if cursor-colors-set is false. + Custom color of the background of the terminal's cursor, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if cursor-colors-set is false. '#ffffff' Cursor foreground colour - Custom color for the foreground of the text character at the terminal's cursor position, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if cursor-colors-set is false. + Custom color for the foreground of the text character at the terminal's cursor position, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if cursor-colors-set is false. false @@ -681,12 +684,14 @@ '#000000' Highlight background color - Custom color of the background of the terminal's highlight, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if highlight-colors-set is false. + Custom color of the background of the terminal's highlight, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if highlight-colors-set is false. '#ffffff' Highlight foreground colour - Custom color for the foreground of the text character at the terminal's highlight position, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if highlight-colors-set is false. + Custom color for the foreground of the text character at the terminal's highlight position, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if highlight-colors-set is false. ["#2E2E34343636", @@ -708,7 +713,7 @@ Palette for terminal applications - true + false Whether to use the colors from the theme for the terminal widget @@ -719,12 +724,14 @@ 8192 Number of lines to keep in scrollback - Number of scrollback lines to keep around. You can scroll back in the terminal by this number of lines; lines that don't fit in the scrollback are discarded. If scrollback_unlimited is true, this value is ignored. + Number of scrollback lines to keep around. You can scroll back in the terminal by this number of lines; lines that don't fit in the scrollback are discarded. If scrollback_unlimited is true, this value is ignored. false Whether an unlimited number of lines should be kept in scrollback - If true, scrollback lines will never be discarded. The scrollback history is stored on disk temporarily, so this may cause the system to run out of disk space if there is a lot of output to the terminal. + If true, scrollback lines will never be discarded. The scrollback history is stored on disk temporarily, so this may cause the system to run out of disk space if there is a lot of output to the terminal. true @@ -758,13 +765,15 @@ '-,./?%&#:_' Characters which are considered as part of word-wise selection - Set of characters which will be considered parts of a word when doing word-wise selection, in addition to the default which only considers alphanumeric characters part of a word. + Set of characters which will be considered parts of a word when doing word-wise selection, in addition to the default which only considers alphanumeric characters part of a word. 'close' What to do with the terminal when the child command exits - Possible values are "close" to close the terminal, "restart" to restart the command, and "hold" to keep the terminal open with no command running inside. + Possible values are "close" to close the terminal, "restart" to restart the command, and "hold" to keep the terminal open with no command running inside. false @@ -879,7 +888,8 @@ '#ffffff' Badge colour - Custom color for the badge, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if badge-color-set is false. + Custom color for the badge, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if badge-color-set is false. false @@ -909,13 +919,15 @@ 0 The threshold for no activity before new activity notifies - When the threshold is non-zero, the terminal will output a notification if output is detected after a period of silence exceeds the threshold. + When the threshold is non-zero, the terminal will output a notification if output is detected after a period of silence exceeds the threshold. '#ffffff' Bold colour - Custom color for bold text, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if bold-color-set is false. + Custom color for bold text, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if bold-color-set is false. false @@ -1016,6 +1028,10 @@ '<Alt>9' Keyboard shortcut to switch to terminal 9 + + '<Alt>0' + Keyboard shortcut to switch to terminal 10 + '<Alt>Up' Keyboard shortcut to switch to terminal above @@ -1064,6 +1080,10 @@ 'F12' Keyboard shortcut to view session sidebar + + '' + Keyboard shortcut to view session switcher + '<Ctrl><Alt>0' Keyboard shortcut to switch to session 10 @@ -1104,6 +1124,10 @@ '<Ctrl><Alt>9' Keyboard shortcut to switch to session 9 + + '<Ctrl><Alt>0' + Keyboard shortcut to switch to session 10 + '<Ctrl>Page_Down' Keyboard shortcut to switch to the next session diff --git a/dub.json b/dub.json index bebf2ff31..d22b651bf 100644 --- a/dub.json +++ b/dub.json @@ -1,53 +1,47 @@ { - "name": "tilix", - "description": "A VTE based terminal emulator for Linux", - "copyright": "Copyright © 2016, Gerald Nunn", - "authors": ["Gerald Nunn"], - "mainSourceFile": "source/app.d", - "dflags-ldc": ["-disable-linker-strip-dead","-link-defaultlib-shared=false"], - "dependencies": { - "gtk-d:gtkd": { - "version": "3.11.0" - }, - "gtk-d:vte": { - "version": "3.11.0" - } + "name": "tilix", + "description": "A VTE based terminal emulator for Linux", + "copyright": "Copyright © 2016, Gerald Nunn", + "authors": ["Gerald Nunn"], + "mainSourceFile": "source/app.d", + "dflags-ldc": ["-disable-linker-strip-dead", "-link-defaultlib-shared=false"], + "dependencies": { + "gid:gtk3": "0.9.7", + "gid:vte2": "0.9.7", + "gid:gdk3": "0.9.7", + "gid:gio2": "0.9.7", + "gid:glib2": "0.9.7", + "gid:gdkpixbuf2": "0.9.7", + "gid:pango1": "0.9.7", + "gid:pangocairo1": "0.9.7", + "gid:cairo1": "0.9.7", + "gid:secret1": "0.9.7" + }, + "buildTypes": { + "release": {}, + "debug": { + "debugVersions": ["GC"], + "dflags": ["-g"] }, - "buildTypes": { - "release": { - }, - "debug": { - "debugVersions": ["GC"], - "dflags": ["-g"] - }, - "localize": { - "versions": ["Localize"] - }, - "i686": { - "dflags": ["-m32", "-c"] - } + "localize": { + "versions": ["Localize"] }, - - "configurations": [ - { - "name": "default", - "targetType": "executable", - "libs-linux": ["X11"], - "versions": ["StdLoggerDisableTrace"] - }, - { - "name": "trace", - "targetType": "executable", - "libs-linux": ["X11"], - "debugVersions": ["Destructors"] - }, - { - "name": "dynamic", - "targetType": "executable", - "libs": ["gtkd-3"], - "libs-linux": ["X11"], - "lflags": ["-defaultlib=libgtkd-3.so"], - "versions": ["StdLoggerDisableTrace"] - } - ] + "i686": { + "dflags": ["-m32", "-c"] + } + }, + "configurations": [ + { + "name": "default", + "targetType": "executable", + "libs-linux": ["X11"], + "versions": ["StdLoggerDisableTrace"] + }, + { + "name": "trace", + "targetType": "executable", + "libs-linux": ["X11"], + "debugVersions": ["Destructors"] + } + ] } diff --git a/dub.selections.json b/dub.selections.json index a43c280db..7183c5f37 100644 --- a/dub.selections.json +++ b/dub.selections.json @@ -1,6 +1,6 @@ { - "fileVersion": 1, - "versions": { - "gtk-d": "3.11.0" - } + "fileVersion": 1, + "versions": { + "gid": "0.9.7" + } } diff --git a/meson.build b/meson.build index d790a897c..d553e0e0b 100644 --- a/meson.build +++ b/meson.build @@ -5,15 +5,6 @@ project( meson_version: '>= 0.56' ) -compiler = meson.get_compiler('d') -if compiler.get_id() == 'llvm' - d_extra_args = ['-vcolumns'] - d_link_args = [] -else - d_extra_args = [] - d_link_args = [] -endif - project_id = 'com.gexperts.Tilix' project_name = meson.project_name() @@ -28,106 +19,30 @@ schemadir = datadir / 'glib-2.0' / 'schemas' iconsdir = datadir / 'icons' / 'hicolor' appdir = datadir / 'applications' -tilix_sources = [ - 'source/gx/gtk/actions.d', - 'source/gx/gtk/cairo.d', - 'source/gx/gtk/clipboard.d', - 'source/gx/gtk/color.d', - 'source/gx/gtk/dialog.d', - 'source/gx/gtk/resource.d', - 'source/gx/gtk/settings.d', - 'source/gx/gtk/threads.d', - 'source/gx/gtk/util.d', - 'source/gx/gtk/vte.d', - 'source/gx/gtk/x11.d', - 'source/gx/i18n/l10n.d', - 'source/gx/tilix/bookmark/bmchooser.d', - 'source/gx/tilix/bookmark/bmeditor.d', - 'source/gx/tilix/bookmark/bmtreeview.d', - 'source/gx/tilix/bookmark/manager.d', - 'source/gx/tilix/prefeditor/advdialog.d', - 'source/gx/tilix/prefeditor/bookmarkeditor.d', - 'source/gx/tilix/prefeditor/common.d', - 'source/gx/tilix/prefeditor/prefdialog.d', - 'source/gx/tilix/prefeditor/profileeditor.d', - 'source/gx/tilix/prefeditor/titleeditor.d', - 'source/gx/tilix/terminal/actions.d', - 'source/gx/tilix/terminal/activeprocess.d', - 'source/gx/tilix/terminal/advpaste.d', - 'source/gx/tilix/terminal/exvte.d', - 'source/gx/tilix/terminal/layout.d', - 'source/gx/tilix/terminal/monitor.d', - 'source/gx/tilix/terminal/password.d', - 'source/gx/tilix/terminal/regex.d', - 'source/gx/tilix/terminal/search.d', - 'source/gx/tilix/terminal/terminal.d', - 'source/gx/tilix/terminal/util.d', - 'source/gx/tilix/application.d', - 'source/gx/tilix/appwindow.d', - 'source/gx/tilix/closedialog.d', - 'source/gx/tilix/cmdparams.d', - 'source/gx/tilix/colorschemes.d', - 'source/gx/tilix/common.d', - 'source/gx/tilix/constants.d', - 'source/gx/tilix/customtitle.d', - 'source/gx/tilix/encoding.d', - 'source/gx/tilix/preferences.d', - 'source/gx/tilix/session.d', - 'source/gx/tilix/shortcuts.d', - 'source/gx/tilix/sidebar.d', - 'source/gx/util/array.d', - 'source/gx/util/path.d', - 'source/gx/util/string.d', - 'source/secret/Collection.d', - 'source/secret/Item.d', - 'source/secret/Prompt.d', - 'source/secret/Schema.d', - 'source/secret/SchemaAttribute.d', - 'source/secret/Secret.d', - 'source/secret/Service.d', - 'source/secret/Value.d', - 'source/secretc/secret.d', - 'source/secretc/secrettypes.d', - 'source/x11/X.d', - 'source/x11/Xlib.d', - 'source/app.d' -] - -sources_dir = include_directories('source/') - -# Dependencies -gtkd_dep = dependency('gtkd-3', version: '>=3.10.0') -vted_dep = dependency('vted-3', version: '>=3.10.0') +# Dependencies (for pkg-config checks only, actual linking done by dub) xlib_dep = dependency('x11') libsecret_dep = dependency('libsecret-1', required: false) subdir('po') subdir('data') -# Build & Test -executable('tilix', - [tilix_sources, gresource], - include_directories : sources_dir, - dependencies : [gtkd_dep, - vted_dep, - xlib_dep, - libsecret_dep], - d_args: d_extra_args, - d_module_versions: ['StdLoggerDisableTrace'], - link_args: d_link_args, - install : true -) - -tilix_test_exe = executable('tilix_test', - [tilix_sources], - include_directories : [sources_dir], - dependencies : [gtkd_dep, - vted_dep, - xlib_dep], - d_args: d_extra_args, - link_args: d_link_args, - d_unittest: true +# Build using dub with GDC compiler +# We use a custom_target because gid bindings are D source packages +# that need to be compiled by dub, not meson's D support + +tilix_dub = custom_target('tilix', + output: 'tilix', + command: [ + 'sh', '-c', + 'cd @0@ && dub build --compiler=gdc --build=debug && cp tilix @1@/'.format( + meson.current_source_dir(), + meson.current_build_dir() + ) + ], + build_by_default: true, + console: true, + install: true, + install_dir: bindir ) -test('tilix_test', tilix_test_exe) meson.add_install_script('meson_post_install.py') diff --git a/schemas/com.gexperts.Tilix.gschema.xml b/schemas/com.gexperts.Tilix.gschema.xml new file mode 100644 index 000000000..1bd44d538 --- /dev/null +++ b/schemas/com.gexperts.Tilix.gschema.xml @@ -0,0 +1,1311 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + The window state (maximized, minimized, etc) to restore + Saves the last window state on exit and restores it upon new invocation + + + false + If true, the window state is saved and restored between invocations + If true, saves the last window state on exit and restores it upon new invocation + + + 'normal' + Style to use for displaying the tilix window + The style to use for displaying the tilix window, enables disabling Client-Side_Decorations. + + + '${appName}: ${sessionName}' + The application title that is used + The title to use for the application, can be composed of literal strings and supported tokens. + + + false + Whether to automatically hide the mouse pointer when typing + If true, the mouse pointer is hidden when the user starts typing and shown again when interaction with the mouse occurs. + + + false + Whether to prompt for session settings or use defaults + If true, when creating a new session a prompt will appear to pick the session name and profile used. + + + true + Whether to prompt on close when multiple sessions are active + If true, a prompt is shown confirming closing the window when multiple sessions are active. + + + true + Whether to prompt on close when processes are still running + If true, a prompt is shown confirming closing the window when processes are running. + + + true + Whether to prompt on profile deletion + If true, a prompt is shown confirming the deletion of a profile. + + + '${title}' + The default name to use for a session + The default name of the session, terminal variables can be used in which case the active terminal resolves the variables. + + + true + Whether transparency is enabled + If true, transparency is enabled in terminals. + + + 'normal' + The style to use for terminal titles + Which style to use for terminal titles, normal, small or none. + + + true + Show the terminal title even if its the only terminal + When enabled, the terminal title bar will remain visible when only a single terminal exists in the session + + + false + Whether splitters use a narrow (default) or wide handle + If true, splitters between terminals use a wide handle. Only supported in GTK 2.16 and later. + + + true + Whether the window should close when the last session is closed + If false, when the last session is closed, a new session is opened. + + + true + If true, uses an overlay scrollbar instead of a separate widget + If true, uses an overlay scrollbar instead of a separate widget if GTK is 3.22 or greater. + + + + 'system' + Which theme variant to use + + + + 'new-window' + Default behavior when opening a second instance of Tilix + + + + true + Whether to notify when a process is completed + If true, notifications will be sent when non-visible processes complete in terminals. + + + + false + Whether the standard GTK shortcut for menubar access is enabled + Normally you can access the menubar with F10. This can also be customized via gtkrc (gtk-menu-bar-accel = "whatever"). This option allows the standard menubar accelerator to be disabled. + + + + false + Whether clicking the middle mouse button closes the terminal + When true, clicking the middle mouse button on the terminal title bar will close it. + + + + false + Whether the control key and the mouse wheel zooms the terminal + When true, using the control key with the mouse scroll wheel will zoom the terminal in and out. + + + + true + Whether accelerators for shortcuts are enabled + When this is false, accelerators are disabled and any accelerators set will be ignored. + + + + true + Alert the user about unsafe paste + Warn the user when pasting a command into the terminal that might be considered unsafe. + + + false + Strip the first character from a paste when comment or variable declaration + If true, if the first character is a comment (#) or a variable declaration($) it will be stripped on paste. + + + false + Strip trailing whitespace on paste. + If true, trailing whitespace will be stripped when pasting. + + + false + Use the advanced paste as the default paste + If true, the advanced paste dialog is always used when paste is activated. + + + false + Automatically copy selected text to clipboard + If true, when text is selected in the terminal it is automatically copied to the clipboard. + + + + false + Whether to match case + If true, searches will be case sensitive. + + + false + Whether to match the entire word + If true, search must be the entire word in order to be considered a match. + + + false + Whether to match using regular expressions + If true, the search will be done treating the search text as a regular expression. + + + false + Whether regular expression option is always enabled in search dialog + If true, search will always be done using regular expressions. + + + true + Whether searches wrap the terminal buffer + If true, a search will move to the bottom of the terminal buffer when it reaches the top item and vice versa. + + + + ["UTF-8"] + List of available encodings + + A subset of possible encodings are presented in + the Encoding submenu. This is a list of encodings + to appear there. + + + + true + Whether to warn if the VTE configuration issue is detected + If true, a dialog will be displayed warning the user that VTE is not configured correctly. + + + false + Whether the focus follows the mouse + If true, a terminal will automatically be focused when the mouse moves over it. + + + + '' + Path of the background image + The path of the image to use for the background, requires transparency support. + + + 'scale' + The mode to use when rendering the background image + Whether the background image is rendered scaled, tiled or centered in Tilix. + + + 'bilinear' + The algorithm to use when scaling the background image + The cairo filter algorithm used to scale the background image, performance will deteroriate with higher quality. + + + true + Whether to include return character with password + If true, when selecting a password to submit to the terminal a return character will automatically be added. + + + true + Whether to include return character with bookmark + If true, when selecting a bookmark to submit to the terminal a return character will automatically be added. + + + false + Whether the sidebar should be on the right + If true, the sidebar will be attached to the right side of the window rather than the left. + + + + + 40 + The height of the terminal as a percent of the screen height + When in quake mode, the height of the terminal as a percentage of the screen height. + + + + 100 + The width of the terminal as a percent of the screen width + When in quake mode, the width of the terminal as a percentage of the screen width. + + + true + Display the terminal on the active monitor + When in quake mode, always display the terminal on the active monitor. + + + 0 + Display the terminal on a specific monitor if available + When in quake mode, display the terminal on the specified monitor. + + + true + Display the terminal on all workspaces + When in quake mode, display the terminal on all workspaces. + + + + false + Hide the quake window when focus is lost + When true, the quake window will be hidden automatically when focus is lost. + + + 150 + Delay used to hide the quake window when focus is lost + Delay used to hide the quake window so that quick changes in focus do not hide the window. + + + 'center' + The alignment of the quake window + The alignment of the quake window when the width is less then 100%. + + + false + Hide the headerbar when running in quake mode + When true, the headerbar of the quake window will be hidden. + + + 'top' + The position where the tabs are displayed in Quake mode + Determines where the tabs are displayed relative to the notebook in quake mode. + + + true + When true the quake window is always kept on top + When true, the quake window will be kept on top of all other windows. + + + 'top' + The position where the window is displayed in Quake mode + Determines where the window is displayed relative to the screen in quake mode. + + + + + false + Replace tabs with spaces + If true, replaces tabs with spaces in advanced paste. + + + 4 + The number of spaces to use when replacing tabs + When using advanced paste, the number of spaces to use when replacing tabs. + + + false + Replace CRLF with LF + If true, replaces CRLF sequences with LF in advanced paste. + + + [] + List of recent session files used + A list of recently used session files, used for quick loading. + + + + + true + Set proxy environment variables + If true, sets the proxy environment variables if configured in Gnome. + + + + + false + Whether to require control modifier to edit title on click + If true, editing the title requires using the control key modifier when clicking. + + + + + false + Whether to to enable the process monitor + If true, the process monitor will be enabled and the option to add the process name to the title will be available. + + + + + [] + A list of custom links that can be clicked on in the terminal + A list of custom links, each link consists of a regex and optional launcher encoded according to CSV rules. + + + [] + A list of definitions that trigger actions based on content matches + A list of trigger definitions with each definition consisting of a regex, action to trigger and parameter. + + + 256 + The maximum number of lines to check for trigger matches + When the terminal reports a block of text, this setting determines how many lines are checked for trigger matches starting with the last line. + + + false + Whether an unlimited number of lines should be processed for triggers + If true, all available lines will be processed for triggers. When outputing large amounts of text to the terminal this may impact performance. + + + + false + When true tabs are shown instead of the sidebar + If true, notebook tabs are used instead of the sidebar as the UI metaphor for sessions. + + + 'top' + The position where the tabs are displayed + Determines where the tabs are displayed relative to the notebook. + + + + + + + + [] + + + '' + + + + + + + ['2b7c4080-0ddd-46c5-8f23-563fd3ba789d'] + '2b7c4080-0ddd-46c5-8f23-563fd3ba789d' + + + + + + + 'Unnamed' + Human-readable name of the profile + Human-readable name of the profile. + + + 'disabled' + Keyboard shortcut to switch to profile + + + + 80 + Default number of columns + Number of columns in newly created terminal windows. Has no effect if use_custom_default_size is not enabled. + + + + 24 + Default number of rows + Number of rows in newly created terminal windows. Has no effect if use_custom_default_size is not enabled. + + + + 1.0 + Scale factor for the cell height to increase line spacing. (Does not increase the font’s height.) + + + + 1.0 + Scale factor for the cell width to increase letter spacing. (Does not increase the font’s width.) + + + 'system' + Whether to blink the cursor + The possible values are "system" to use the global cursor blinking settings, or "on" or "off" to set the mode explicitly. + + + 'block' + The cursor appearance + + + 'always' + Whether to enable blinking text + The possible values are "never" to disable text blinking, "always" to enable, or "focused" or "unfocused" to set the mode explicitly. + + + 'sound' + What to do when a bell signal is emitted in a terminal + Determines whether to do nothing, play a sound, show an icon or do both when a bell signal is emitted. + + + true + Whether to allow bold text + If true, allow applications in the terminal to make text boldface. + + + true + Whether bold is also bright + If true, setting bold on the first 8 colors also switches to their bright variants. + + + true + Whether to rewrap the terminal contents on window resize + + + + true + Whether to use the system monospace font + + + 'Monospace 12' + A Pango font name and size + + + 80 + Draws a margin line at the column specified + Draws a margin line at the column specified, 0 indicates no margin. + + + + + 0 + The amount of transparency to apply to the background + + + + + 0 + The amount of transparency to apply to the unfocused dim effect + + + + '#00FF00' + Default color of text in the terminal + Default color of text in the terminal, as a color specification (can be HTML-style hex digits, or a color name such as "red"). + + + '#000000' + Default color of terminal background + Default color of terminal background, as a color specification (can be HTML-style hex digits, or a color name such as "red"). + + + false + Whether to use custom cursor colors + If true, use the cursor colors from the profile. + + + '#000000' + Cursor background color + Custom color of the background of the terminal's cursor, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if cursor-colors-set is false. + + + '#ffffff' + Cursor foreground colour + Custom color for the foreground of the text character at the terminal's cursor position, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if cursor-colors-set is false. + + + false + Whether to use custom highlight colors + If true, use the highlight colors from the profile. + + + '#000000' + Highlight background color + Custom color of the background of the terminal's highlight, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if highlight-colors-set is false. + + + '#ffffff' + Highlight foreground colour + Custom color for the foreground of the text character at the terminal's highlight position, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if highlight-colors-set is false. + + + ["#2E2E34343636", + "#CCCC00000000", + "#4E4E9A9A0606", + "#C4C4A0A00000", + "#34346565A4A4", + "#757550507B7B", + "#060698209A9A", + "#D3D3D7D7CFCF", + "#555557575353", + "#EFEF29292929", + "#8A8AE2E23434", + "#FCFCE9E94F4F", + "#72729F9FCFCF", + "#ADAD7F7FA8A8", + "#3434E2E2E2E2", + "#EEEEEEEEECEC"] + Palette for terminal applications + + + true + Whether to use the colors from the theme for the terminal widget + + + + true + When to show the scrollbar + + + 8192 + Number of lines to keep in scrollback + Number of scrollback lines to keep around. You can scroll back in the terminal by this number of lines; lines that don't fit in the scrollback are discarded. If scrollback_unlimited is true, this value is ignored. + + + false + Whether an unlimited number of lines should be kept in scrollback + If true, scrollback lines will never be discarded. The scrollback history is stored on disk temporarily, so this may cause the system to run out of disk space if there is a lot of output to the terminal. + + + true + Whether to scroll to the bottom when a key is pressed + If true, pressing a key jumps the scrollbar to the bottom. + + + false + Whether to scroll to the bottom when there's new output + If true, whenever there's new output the terminal will scroll to the bottom. + + + + 'ascii-delete' + The code sequence the Backspace key generates + + + 'delete-sequence' + The code sequence the Delete key generates + + + 'narrow' + Whether ambiguous-width characters are narrow or wide when using UTF-8 encoding + + + + '${id}: ${title}' + The string to display as the terminal title + The title supports tokens which are replaced at runtime, additionally pango markup can be used as well. + + + '-,./?%&#:_' + Characters which are considered as part of word-wise selection + Set of characters which will be considered parts of a word when doing word-wise selection, in addition to the default which only considers alphanumeric characters part of a word. + + + + 'close' + What to do with the terminal when the child command exits + Possible values are "close" to close the terminal, "restart" to restart the command, and "hold" to keep the terminal open with no command running inside. + + + false + Whether to launch the command in the terminal as a login shell + If true, the command inside the terminal will be launched as a login shell (argv[0] will have a hyphen in front of it). + + + false + Whether to run a custom command instead of the shell + If true, the value of the custom_command setting will be used in place of running a shell. + + + '' + Custom command to use instead of the shell + Run this command in place of the shell, if use_custom_command is true. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 'UTF-8' + Which encoding to use + + + [] + Automatically make this profile active when match detected + Profile becomes active automatically when the current hostname and directory match one of the hostname:value pairs in this list. + + + [] + A list of custom links that can be clicked on in the terminal + A list of custom links, each link consists of a regex and optional launcher encoded according to CSV rules. + + + [] + A list of definitions that trigger actions based on content matches + A list of trigger definitions with each definition consisting of a regex, action to trigger and parameter. + + + + '' + Whether to display a background badge + When set, a badge will be rendered in the background of the terminal + + + '#ffffff' + Badge colour + Custom color for the badge, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if badge-color-set is false. + + + false + Whether to use custom badge color + If true, use the badge color from the profile. + + + 'northeast' + The position where the badge is displayed + Determines the position based on quadrants whre the badge is rendered in the terminal. + + + true + Whether to use the system monospace font + + + 'Monospace 12' + A Pango font name and size + + + + + false + Enable monitoring activity by default + When enabled, new terminals will automatically monitor activity by default. + + + 0 + The threshold for no activity before new activity notifies + When the threshold is non-zero, the terminal will output a notification if output is detected after a period of silence exceeds the threshold. + + + + '#ffffff' + Bold colour + Custom color for bold text, as a color specification (can be HTML-style hex digits, or a color name such as "red"). This is ignored if bold-color-set is false. + + + false + Whether to use custom bold color + If true, use the bold color from the profile. + + + + + + + + + '<Shift><Ctrl>N' + Keyboard shortcut to create a new window + + + '<Shift><Ctrl>T' + Keyboard shortcut to create a new session + + + 'disabled' + Keyboard shortcut to open preferences + + + 'disabled' + Keyboard shortcut to show shortcuts + + + 'disabled' + Keyboard shortcut to synchronize input for the session + + + '<Shift><Ctrl>Q' + Keyboard shortcut to close a session + + + 'disabled' + Keyboard shortcut to change the name of the session + + + '<Shift><Ctrl>o' + Keyboard shortcut to open a previously saved session + + + '<Shift><Ctrl>s' + Keyboard shortcut to save the current session + + + 'disabled' + Keyboard shortcut to save the current session as a new file + + + '<Alt>0' + Keyboard shortcut to switch to terminal 0 + + + '<Alt>1' + Keyboard shortcut to switch to terminal 1 + + + '<Alt>2' + Keyboard shortcut to switch to terminal 2 + + + '<Alt>3' + Keyboard shortcut to switch to terminal 3 + + + '<Alt>4' + Keyboard shortcut to switch to terminal 4 + + + '<Alt>5' + Keyboard shortcut to switch to terminal 5 + + + '<Alt>6' + Keyboard shortcut to switch to terminal 6 + + + '<Alt>7' + Keyboard shortcut to switch to terminal 7 + + + '<Alt>8' + Keyboard shortcut to switch to terminal 8 + + + '<Alt>9' + Keyboard shortcut to switch to terminal 9 + + + '<Alt>0' + Keyboard shortcut to switch to terminal 10 + + + '<Alt>Up' + Keyboard shortcut to switch to terminal above + + + '<Alt>Down' + Keyboard shortcut to switch to terminal below + + + '<Alt>Left' + Keyboard shortcut to switch to terminal left + + + '<Alt>Right' + Keyboard shortcut to switch to terminal right + + + '<Shift><Alt>Up' + Keyboard shortcut to resize terminal up + + + '<Shift><Alt>Down' + Keyboard shortcut to resize terminal down + + + '<Shift><Alt>Left' + Keyboard shortcut to resize terminal left + + + '<Shift><Alt>Right' + Keyboard shortcut to resize terminal right + + + '<Ctrl><Alt>r' + Keyboard shortcut to add new terminal right + + + '<Ctrl><Alt>d' + Keyboard shortcut to add new terminal down + + + '<Ctrl><Alt>a' + Keyboard shortcut to add new terminal automatically + + + 'F12' + Keyboard shortcut to view session sidebar + + + '' + Keyboard shortcut to view session switcher + + + '<Ctrl><Alt>0' + Keyboard shortcut to switch to session 10 + + + '<Ctrl><Alt>1' + Keyboard shortcut to switch to session 1 + + + '<Ctrl><Alt>2' + Keyboard shortcut to switch to session 2 + + + '<Ctrl><Alt>3' + Keyboard shortcut to switch to session 3 + + + '<Ctrl><Alt>4' + Keyboard shortcut to switch to session 4 + + + '<Ctrl><Alt>5' + Keyboard shortcut to switch to session 5 + + + '<Ctrl><Alt>6' + Keyboard shortcut to switch to session 6 + + + '<Ctrl><Alt>7' + Keyboard shortcut to switch to session 7 + + + '<Ctrl><Alt>8' + Keyboard shortcut to switch to session 8 + + + '<Ctrl><Alt>9' + Keyboard shortcut to switch to session 9 + + + '<Ctrl><Alt>0' + Keyboard shortcut to switch to session 10 + + + '<Ctrl>Page_Down' + Keyboard shortcut to switch to the next session + + + '<Ctrl>Page_Up' + Keyboard shortcut to switch to the previous session + + + '<Ctrl><Shift>Page_Up' + Keyboard shortcut to reorder to the previous session + + + '<Ctrl><Shift>Page_Down' + Keyboard shortcut to reorder to the next session + + + 'F11' + Keyboard shortcut to toggle fullscreen + + + + '<Ctrl>Tab' + Keyboard shortcut to switch to the next terminal + + + '<Ctrl><Shift>Tab' + Keyboard shortcut to switch to the previous terminal + + + '<Ctrl><Shift>f' + Keyboard shortcut to find text in terminal + + + '<Ctrl><Shift>g' + Keyboard shortcut to find next match in terminal + + + '<Ctrl><Shift>h' + Keyboard shortcut to find previous match in terminal + + + 'disabled' + Keyboard shortcut to set a customize layout options for the terminal + + + '<Shift><Ctrl>W' + Keyboard shortcut to close the terminal + + + '<Shift><Ctrl>X' + Keyboard shortcut to maximize or restore the terminal + + + 'disabled' + Keyboard shortcut to edit the current profile + + + 'disabled' + Keyboard shortcut to toggle whether the terminal is read-only + + + 'disabled' + Keyboard shortcut to reset the terminal states + + + 'disabled' + Keyboard shortcut to reset the terminal states and clear the output buffer + + + '<Ctrl><Shift>c' + Keyboard shortcut to copy selected text in terminal + + + 'disabled' + Keyboard shortcut to copy selected text in terminal as HTML + + + '<Ctrl><Shift>v' + Keyboard shortcut to paste text in terminal from clipboard + + + '<Shift>Insert' + Keyboard shortcut to paste text in terminal from primary selection + + + 'disabled' + Keyboard shortcut to paste text in terminal from clipboard via advanced paste dialog + + + '<Ctrl><Shift>a' + Keyboard shortcut to select all text in terminal + + + 'disabled' + Keyboard shortcut to unselect all text in terminal + + + '<Ctrl>plus' + Keyboard shortcut to make font larger + + + '<Ctrl>minus' + Keyboard shortcut to make font smaller + + + '<Ctrl>0' + Keyboard shortcut to make font normal-size + + + 'disabled' + Keyboard shortcut to save terminal contents + + + 'disabled' + Keyboard shortcut to insert the current terminal number + + + 'disabled' + Keyboard shortcut to insert a password into the terminal + + + 'disabled' + Keyboard shortcut to cycle the terminal title styles + + + '<Ctrl><Shift>b' + Keyboard shortcut to select a bookmark + + + 'disabled' + Keyboard shortcut to add a bookmark + + + '<Ctrl><Shift>Up' + Keyboard shortcut to scroll up + + + '<Ctrl><Shift>Down' + Keyboard shortcut to scroll down + + + '<Shift>Page_Up' + Keyboard shortcut to page up + + + '<Shift>Page_Down' + Keyboard shortcut to page down + + + 'disabled' + Keyboard shortcut to toggle silence monitor + + + 'disabled' + Keyboard shortcut to toggle input synchronization override + + + 'disabled' + Keyboard shortcut to open directory in file browser + + + + 'disabled' + Keyboard shortcut to move to next prompt + + + 'disabled' + Keyboard shortcut to move to previous prompt + + + '<Ctrl><Alt>m' + Keyboard shortcut to toggle margin display + + + + '<Ctrl><Alt>t' + Keyboard shortcut used in Nautilus for Open Here extension + + + diff --git a/source/app.d b/source/app.d index 7f453e025..a884feb7e 100644 --- a/source/app.d +++ b/source/app.d @@ -11,12 +11,21 @@ import std.format; import std.process; import std.string; -import glib.FileUtils; -import glib.Util; +// GID imports - glib +import glib.global : getCurrentDir, getHomeDir, setPrgname, chdir; -import gtk.Main; -import gtk.Version; -import gtk.MessageDialog; +// GID imports - gtk +import gtk.c.functions : gtk_init, gtk_message_dialog_new; +import gtk.types : DialogFlags, MessageType, ButtonsType; +import gtk.c.types : GtkWidget, GtkWindow; +import gtk.global : checkVersion, getMajorVersion, getMinorVersion, getMicroVersion; +import gtk.message_dialog : MessageDialog; +import gtk.types : DialogFlags, MessageType, ButtonsType, ResponseType; + +// GID imports - gobject +import gobject.object : ObjectWrap; + +import gid.gid : No; import gx.i18n.l10n; import gx.gtk.util; @@ -34,7 +43,7 @@ int main(string[] args) { bool newProcess = false; string group; - string cwd = Util.getCurrentDir(); + string cwd = getCurrentDir(); string pwd; string de; trace("CWD = " ~ cwd); @@ -51,7 +60,7 @@ int main(string[] args) { error("Unexpected error occurred", e); } - string uhd = Util.getHomeDir(); + string uhd = getHomeDir(); trace("UHD = " ~ uhd); //Debug args @@ -99,10 +108,10 @@ int main(string[] args) { //textdomain textdomain(TILIX_DOMAIN); // Set application ID for GTK3 on Wayland - Util.setPrgname(APPLICATION_ID); + setPrgname(APPLICATION_ID); // Init GTK early so localization is available // Note used to pass empty args but was interfering with GTK default args - Main.init(args); + gtk_init(null, null); trace(format("Starting tilix with %d arguments...", args.length)); foreach(i, arg; args) { @@ -113,7 +122,7 @@ int main(string[] args) { infof("CWD = %s", cwd); infof("PWD = %s", pwd); cwd = pwd; - FileUtils.chdir(cwd); + chdir(cwd); } else if (arg == "--new-process") { newProcess = true; } else if (arg == "-g") { @@ -136,23 +145,39 @@ int main(string[] args) { } //Version checking cribbed from grestful, thanks! - string gtkError = Version.checkVersion(GTK_VERSION_MAJOR, GTK_VERSION_MINOR, GTK_VERSION_PATCH); + string gtkError = checkVersion(GTK_VERSION_MAJOR, GTK_VERSION_MINOR, GTK_VERSION_PATCH); if (gtkError !is null) { - MessageDialog dialog = new MessageDialog(null, DialogFlags.MODAL, MessageType.ERROR, ButtonsType.OK, - format(_("Your GTK version is too old, you need at least GTK %d.%d.%d!"), GTK_VERSION_MAJOR, GTK_VERSION_MINOR, GTK_VERSION_PATCH), null); - dialog.setDefaultResponse(ResponseType.OK); - + DialogFlags flags = DialogFlags.Modal; + GtkWidget* widget = gtk_message_dialog_new( + null, + flags, + MessageType.Error, + ButtonsType.Ok, + format(_("Your GTK version is too old, you need at least GTK %d.%d.%d!"), GTK_VERSION_MAJOR, GTK_VERSION_MINOR, GTK_VERSION_PATCH).ptr, + null + ); + MessageDialog dialog = ObjectWrap._getDObject!MessageDialog(cast(void*) widget, No.Take); + dialog.setDefaultResponse(ResponseType.Ok); dialog.run(); + dialog.destroy(); return 1; } // check minimum VTE version if (!checkVTEVersion(VTE_VERSION_MINIMAL)) { - MessageDialog dialog = new MessageDialog(null, DialogFlags.MODAL, MessageType.ERROR, ButtonsType.OK, - format(_("Your VTE version is too old, you need at least VTE %d.%d!"), VTE_VERSION_MINIMAL[0], VTE_VERSION_MINIMAL[1]), null); - dialog.setDefaultResponse(ResponseType.OK); - + DialogFlags flags = DialogFlags.Modal; + GtkWidget* widget = gtk_message_dialog_new( + null, + flags, + MessageType.Error, + ButtonsType.Ok, + format(_("Your VTE version is too old, you need at least VTE %d.%d!"), VTE_VERSION_MINIMAL[0], VTE_VERSION_MINIMAL[1]).ptr, + null + ); + MessageDialog dialog = ObjectWrap._getDObject!MessageDialog(cast(void*) widget, No.Take); + dialog.setDefaultResponse(ResponseType.Ok); dialog.run(); + dialog.destroy(); return 1; } @@ -174,14 +199,13 @@ int main(string[] args) { private: void outputVersions() { import gx.gtk.vte: getVTEVersion, checkVTEFeature, TerminalFeature, isVTEBackgroundDrawEnabled; - import gtk.Version: Version; writeln(_("Versions")); writeln("\t" ~ format(_("Tilix version: %s"), APPLICATION_VERSION)); writeln("\t" ~ format(_("VTE version: %s"), getVTEVersion())); - writeln("\t" ~ format(_("GTK Version: %d.%d.%d") ~ "\n", Version.getMajorVersion(), Version.getMinorVersion(), Version.getMicroVersion())); + writeln("\t" ~ format(_("GTK Version: %d.%d.%d") ~ "\n", getMajorVersion(), getMinorVersion(), getMicroVersion())); writeln(_("Tilix Special Features")); writeln("\t" ~ format(_("Notifications enabled=%b"), checkVTEFeature(TerminalFeature.EVENT_NOTIFICATION))); writeln("\t" ~ format(_("Triggers enabled=%b"), checkVTEFeature(TerminalFeature.EVENT_SCREEN_CHANGED))); writeln("\t" ~ format(_("Badges enabled=%b"), isVTEBackgroundDrawEnabled)); - } + } \ No newline at end of file diff --git a/source/gx/glib/simplexml.d b/source/gx/glib/simplexml.d new file mode 100644 index 000000000..eb465482e --- /dev/null +++ b/source/gx/glib/simplexml.d @@ -0,0 +1,85 @@ +/* + * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not + * distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +module gx.glib.simplexml; + +import glib.c.types : GMarkupParser, GMarkupParseContext, GMarkupParseFlags, GError, GDestroyNotify; +import glib.c.functions : g_markup_parse_context_new, g_markup_parse_context_free, + g_markup_parse_context_parse, g_markup_parse_context_end_parse, + g_error_free; + +/** + * Simple wrapper around GLib's markup parser (GMarkupParseContext). + * This provides a D-friendly interface to parse XML/markup content. + */ +class SimpleXML { +private: + GMarkupParseContext* context; + +public: + /** + * Creates a new SimpleXML parser. + * + * Params: + * parser = Pointer to a GMarkupParser struct with callback functions + * flags = GMarkupParseFlags to control parsing behavior + * userData = User data to pass to callback functions + * userDataDnotify = Optional destroy notify function (can be null) + */ + this(const(GMarkupParser)* parser, GMarkupParseFlags flags, void* userData, GDestroyNotify userDataDnotify) { + context = g_markup_parse_context_new(parser, flags, userData, userDataDnotify); + if (context is null) { + throw new Exception("Failed to create GMarkupParseContext"); + } + } + + ~this() { + if (context !is null) { + g_markup_parse_context_free(context); + context = null; + } + } + + /** + * Parse the given markup text. + * + * Params: + * text = The markup text to parse + * textLen = Length of the text (use text.length for D strings) + * + * Throws: Exception if parsing fails + */ + void parse(string text, size_t textLen) { + GError* error = null; + bool result = g_markup_parse_context_parse(context, text.ptr, cast(ptrdiff_t)textLen, &error); + if (!result) { + string errorMsg = "Markup parse error"; + if (error !is null) { + import std.string : fromStringz; + errorMsg = error.message.fromStringz.idup; + g_error_free(error); + } + throw new Exception(errorMsg); + } + } + + /** + * End parsing and check for any remaining errors. + * + * Throws: Exception if there are unclosed elements or other errors + */ + void endParse() { + GError* error = null; + bool result = g_markup_parse_context_end_parse(context, &error); + if (!result) { + string errorMsg = "Markup end parse error"; + if (error !is null) { + import std.string : fromStringz; + errorMsg = error.message.fromStringz.idup; + g_error_free(error); + } + throw new Exception(errorMsg); + } + } +} \ No newline at end of file diff --git a/source/gx/gtk/actions.d b/source/gx/gtk/actions.d index 7ad6f5e6a..9b4b54fd6 100644 --- a/source/gx/gtk/actions.d +++ b/source/gx/gtk/actions.d @@ -7,16 +7,22 @@ module gx.gtk.actions; import std.experimental.logger; import std.string; -import gio.ActionMapIF; -import gio.SimpleAction; -import gio.Settings : GSettings = Settings; +// GID imports - gio +import gio.action_map : ActionMap; +import gio.simple_action : SimpleAction; +import gio.settings : Settings; -import glib.Variant: GVariant = Variant; -import glib.VariantType: GVariantType = VariantType; +// GID imports - glib +import glib.variant : Variant; +import glib.variant_type : VariantType; -import gtk.AccelGroup; -import gtk.Application; -import gtk.ApplicationWindow; +// GID imports - gtk +import gtk.application : Application; +import gtk.application_window : ApplicationWindow; +import gtk.global : acceleratorParse, acceleratorGetLabel; + +// GID imports - gdk (for modifier type) +import gdk.types : ModifierType; import gx.i18n.l10n; @@ -29,11 +35,11 @@ enum SHORTCUT_DISABLED = N_("disabled"); */ string acceleratorNameToLabel(string acceleratorName) { uint acceleratorKey; - GdkModifierType acceleratorMods; - AccelGroup.acceleratorParse(acceleratorName, acceleratorKey, acceleratorMods); - string label = AccelGroup.acceleratorGetLabel(acceleratorKey, acceleratorMods); + ModifierType acceleratorMods; + acceleratorParse(acceleratorName, acceleratorKey, acceleratorMods); + string label = acceleratorGetLabel(acceleratorKey, acceleratorMods); if (label == "") { - label = _(SHORTCUT_DISABLED); + label = _(SHORTCUT_DISABLED); } return label; } @@ -89,9 +95,9 @@ string keyToDetailedActionName(string key) { * * Returns: The registered action. */ -SimpleAction registerActionWithSettings(ActionMapIF actionMap, string prefix, string id, GSettings settings, void delegate(GVariant, - SimpleAction) cbActivate = null, GVariantType type = null, GVariant state = null, void delegate(GVariant, - SimpleAction) cbStateChange = null) { +SimpleAction registerActionWithSettings(ActionMap actionMap, string prefix, string id, Settings settings, + void delegate(Variant, SimpleAction) cbActivate = null, VariantType type = null, Variant state = null, + void delegate(Variant, SimpleAction) cbStateChange = null) { string[] shortcuts; try { @@ -125,27 +131,31 @@ SimpleAction registerActionWithSettings(ActionMapIF actionMap, string prefix, st * * Returns: The registered action. */ -SimpleAction registerAction(ActionMapIF actionMap, string prefix, string id, string[] accelerators = null, void delegate(GVariant, - SimpleAction) cbActivate = null, GVariantType parameterType = null, GVariant state = null, void delegate(GVariant, - SimpleAction) cbStateChange = null) { +SimpleAction registerAction(ActionMap actionMap, string prefix, string id, string[] accelerators = null, + void delegate(Variant, SimpleAction) cbActivate = null, VariantType parameterType = null, + Variant state = null, void delegate(Variant, SimpleAction) cbStateChange = null) { SimpleAction action; if (state is null) action = new SimpleAction(id, parameterType); else { - action = new SimpleAction(id, parameterType, state); + action = SimpleAction.newStateful(id, parameterType, state); } if (cbActivate !is null) - action.addOnActivate(cbActivate); + action.connectActivate(cbActivate); if (cbStateChange !is null) - action.addOnChangeState(cbStateChange); + action.connectChangeState(cbStateChange); actionMap.addAction(action); if (accelerators.length > 0) { if (app is null) { - app = cast(Application) Application.getDefault(); + import gio.application : GioApplication = Application; + auto gioApp = GioApplication.getDefault(); + if (gioApp !is null) { + app = cast(Application) gioApp; + } } if (app !is null) { app.setAccelsForAction(prefix.length == 0 ? id : getActionDetailedName(prefix, id), accelerators); @@ -161,4 +171,4 @@ unittest { getActionNameFromKey("terminal-split-horizontal", prefix, id); assert("terminal" == prefix); assert("split-horizontal" == id); -} +} \ No newline at end of file diff --git a/source/gx/gtk/cairo.d b/source/gx/gtk/cairo.d index 1de1d7688..d148f01ee 100644 --- a/source/gx/gtk/cairo.d +++ b/source/gx/gtk/cairo.d @@ -14,26 +14,26 @@ static if (__VERSION__ >= 2075) { } import std.experimental.logger; -import cairo.Context; -import cairo.ImageSurface; -import cairo.Surface; - -import gdk.Cairo; -import gdk.Pixbuf; -import gdk.RGBA; -import gdk.Screen; -import gdk.Visual; -import gdk.Window; -static import gdk.Event; - -import gdkpixbuf.Pixbuf; - -import gtkc.cairotypes; - -import gtk.Container; -import gtk.Main; -import gtk.OffscreenWindow; -import gtk.Widget; +// GID imports - cairo +import cairo.context : Context; +import cairo.global : create, imageSurfaceCreate, imageSurfaceGetWidth, imageSurfaceGetHeight; +import cairo.pattern : Pattern; +import cairo.surface : Surface; +import cairo.types : Content, Extend, Filter, Format, Operator; + +// GID imports - gdk +import gdk.event_expose : EventExpose; +import gdk.global : cairoSetSourcePixbuf, pixbufGetFromSurface; +import gdk.window : GdkWindow = Window; + +// GID imports - gdkpixbuf +import gdkpixbuf.pixbuf : Pixbuf; + +// GID imports - gtk +import gtk.container : Container; +import gtk.global : eventsPending, mainIterationDo; +import gtk.offscreen_window : OffscreenWindow; +import gtk.widget : Widget; Pixbuf getWidgetImage(Widget widget, double factor) { return getWidgetImage(widget, factor, widget.getAllocatedWidth(), widget.getAllocatedHeight()); @@ -53,12 +53,12 @@ Pixbuf getWidgetImage(Widget widget, double factor, int width, int height) { if (widget.isDrawable()) { widget.queueDraw(); static if (__VERSION__ >= 2075) { - while (gtk.Main.Main.eventsPending() && sw.peek.total!"msecs"<100) { - Main.iterationDo(false); + while (eventsPending() && sw.peek.total!"msecs" < 100) { + mainIterationDo(false); } } else { - while (gtk.Main.Main.eventsPending() && sw.peek().msecs<100) { - Main.iterationDo(false); + while (eventsPending() && sw.peek().msecs < 100) { + mainIterationDo(false); } } return getDrawableWidgetImage(widget, factor, width, height); @@ -86,12 +86,12 @@ Pixbuf getWidgetImage(Widget widget, double factor, int width, int height) { solution implemented here. */ static if (__VERSION__ >= 2075) { - while (!window.canDraw && gtk.Main.Main.eventsPending() && sw.peek.total!"msecs"<100) { - Main.iterationDo(false); + while (!window.canDraw && eventsPending() && sw.peek.total!"msecs" < 100) { + mainIterationDo(false); } } else { - while (gtk.Main.Main.eventsPending() && sw.peek().msecs<100) { - Main.iterationDo(false); + while (eventsPending() && sw.peek().msecs < 100) { + mainIterationDo(false); } } // While we could call getPixBuf() on Offscreen Window, drawing @@ -111,47 +111,47 @@ Pixbuf getWidgetImage(Widget widget, double factor, int width, int height) { } } -enum ImageLayoutMode {SCALE, TILE, CENTER, STRETCH}; +enum ImageLayoutMode {SCALE, TILE, CENTER, STRETCH} -ImageSurface renderImage(Pixbuf pb, bool alpha = false) { - cairo_format_t format = alpha?cairo_format_t.ARGB32:cairo_format_t.RGB24; - ImageSurface surface = ImageSurface.create(format, pb.getWidth(), pb.getHeight()); - Context cr = Context.create(surface); +Surface renderImage(Pixbuf pb, bool alpha = false) { + Format format = alpha ? Format.Argb32 : Format.Rgb24; + Surface surface = imageSurfaceCreate(format, pb.getWidth(), pb.getHeight()); + Context cr = create(surface); scope(exit) { - cr.destroy(); + cr = null; } - setSourcePixbuf(cr, pb, 0, 0); - cr.setOperator(cairo_operator_t.SOURCE); + cairoSetSourcePixbuf(cr, pb, 0, 0); + cr.setOperator(Operator.Source); cr.paint(); return surface; } /** - * Renders an image onto an ImageSurface using different modes + * Renders an image onto a Surface using different modes */ -ImageSurface renderImage(Pixbuf pbSource, int outputWidth, int outputHeight, ImageLayoutMode mode, bool alpha = false, cairo_filter_t scaleMode = cairo_filter_t.BILINEAR) { - ImageSurface surface = renderImage(pbSource); +Surface renderImage(Pixbuf pbSource, int outputWidth, int outputHeight, ImageLayoutMode mode, bool alpha = false, Filter scaleMode = Filter.Bilinear) { + Surface surface = renderImage(pbSource); scope(exit) { - surface.destroy(); + surface = null; } return renderImage(surface, outputWidth, outputHeight, mode, alpha, scaleMode); } -ImageSurface renderImage(ImageSurface isSource, int outputWidth, int outputHeight, ImageLayoutMode mode, bool alpha = false, cairo_filter_t scaleMode = cairo_filter_t.BILINEAR) { - cairo_format_t format = alpha?cairo_format_t.ARGB32:cairo_format_t.RGB24; - ImageSurface surface = ImageSurface.create(format, outputWidth, outputHeight); - Context cr = Context.create(surface); +Surface renderImage(Surface isSource, int outputWidth, int outputHeight, ImageLayoutMode mode, bool alpha = false, Filter scaleMode = Filter.Bilinear) { + Format format = alpha ? Format.Argb32 : Format.Rgb24; + Surface surface = imageSurfaceCreate(format, outputWidth, outputHeight); + Context cr = create(surface); scope(exit) { - cr.destroy(); + cr = null; } if (alpha) { - cr.setOperator(cairo_operator_t.SOURCE); + cr.setOperator(Operator.Source); } renderImage(cr, isSource, outputWidth, outputHeight, mode, scaleMode); return surface; } -void renderImage(Context cr, ImageSurface isSource, int outputWidth, int outputHeight, ImageLayoutMode mode, cairo_filter_t scaleMode = cairo_filter_t.BILINEAR) { +void renderImage(Context cr, Surface isSource, int outputWidth, int outputHeight, ImageLayoutMode mode, Filter scaleMode = Filter.Bilinear) { StopWatch sw = StopWatch(AutoStart.yes); scope (exit) { sw.stop(); @@ -159,13 +159,15 @@ void renderImage(Context cr, ImageSurface isSource, int outputWidth, int outputH tracef("Total time getting image: %d msecs", sw.peek.total!"msecs"); } } + int sourceWidth = imageSurfaceGetWidth(isSource); + int sourceHeight = imageSurfaceGetHeight(isSource); final switch (mode) { case ImageLayoutMode.SCALE: - double xScale = to!double(outputWidth) / to!double(isSource.getWidth()); - double yScale = to!double(outputHeight) / to!double(isSource.getHeight()); + double xScale = to!double(outputWidth) / to!double(sourceWidth); + double yScale = to!double(outputHeight) / to!double(sourceHeight); double ratio = max(xScale, yScale); - double xOffset = (outputWidth - (isSource.getWidth() * ratio)) / 2.0; - double yOffset = (outputHeight - (isSource.getHeight() * ratio)) / 2.0; + double xOffset = (outputWidth - (sourceWidth * ratio)) / 2.0; + double yOffset = (outputHeight - (sourceHeight * ratio)) / 2.0; cr.translate(xOffset, yOffset); cr.scale(ratio, ratio); cr.setSourceSurface(isSource, 0, 0); @@ -174,19 +176,19 @@ void renderImage(Context cr, ImageSurface isSource, int outputWidth, int outputH break; case ImageLayoutMode.TILE: cr.setSourceSurface(isSource, 0, 0); - cr.getSource().setExtend(cairo_extend_t.REPEAT); + cr.getSource().setExtend(Extend.Repeat); cr.paint(); break; case ImageLayoutMode.CENTER: - double x = (outputWidth - isSource.getWidth())/2; - double y = (outputHeight - isSource.getHeight())/2; - cr.translate(x,y); + double x = (outputWidth - sourceWidth) / 2; + double y = (outputHeight - sourceHeight) / 2; + cr.translate(x, y); cr.setSourceSurface(isSource, 0, 0); cr.paint(); break; case ImageLayoutMode.STRETCH: - double xScale = to!double(outputWidth) / to!double(isSource.getWidth()); - double yScale = to!double(outputHeight) / to!double(isSource.getHeight()); + double xScale = to!double(outputWidth) / to!double(sourceWidth); + double yScale = to!double(outputHeight) / to!double(sourceHeight); cr.scale(xScale, yScale); cr.setSourceSurface(isSource, 0, 0); cr.getSource().setFilter(scaleMode); @@ -204,23 +206,23 @@ Pixbuf getDrawableWidgetImage(Widget widget, double factor, int width, int heigh int ph = to!int(h * factor); tracef("Factor: %f, New: %d, %d", factor, pw, ph); - Window window = widget.getWindow(); - Surface surface = window.createSimilarSurface(cairo_content_t.COLOR, pw, ph); - Context cr = Context.create(surface); + GdkWindow window = widget.getWindow(); + Surface surface = window.createSimilarSurface(Content.Color, pw, ph); + Context cr = create(surface); scope(exit) { - surface.destroy(); - cr.destroy(); + surface = null; + cr = null; } cr.scale(factor, factor); widget.draw(cr); - Pixbuf pb = getFromSurface(surface, 0, 0, pw, ph); + Pixbuf pb = pixbufGetFromSurface(surface, 0, 0, pw, ph); return pb; } -class RenderWindow: OffscreenWindow { +class RenderWindow : OffscreenWindow { bool _canDraw = false; - bool onDamage(gdk.Event.Event, Widget) { + bool onDamage(EventExpose event, Widget w) { trace("Damage event received"); _canDraw = true; return false; @@ -229,13 +231,13 @@ class RenderWindow: OffscreenWindow { public: this() { super(); - addOnDamage(&onDamage); + connectDamageEvent(&onDamage); show(); } debug(Destructors) { ~this() { - import std.stdio: writeln; + import std.stdio : writeln; writeln("******** RenderWindow Destructor"); } } @@ -243,4 +245,4 @@ public: @property bool canDraw() { return _canDraw; } -} +} \ No newline at end of file diff --git a/source/gx/gtk/clipboard.d b/source/gx/gtk/clipboard.d index 37d2abd6b..a2643ffb4 100644 --- a/source/gx/gtk/clipboard.d +++ b/source/gx/gtk/clipboard.d @@ -4,15 +4,16 @@ */ module gx.gtk.clipboard; -import gdk.Atom; +// GID imports - gdk +import gdk.atom : Atom; /* Clipboard Atoms */ -GdkAtom GDK_SELECTION_CLIPBOARD; -GdkAtom GDK_SELECTION_PRIMARY; -GdkAtom GDK_SELECTION_SECONDARY; +Atom GDK_SELECTION_CLIPBOARD; +Atom GDK_SELECTION_PRIMARY; +Atom GDK_SELECTION_SECONDARY; static this() { - GDK_SELECTION_CLIPBOARD = intern("CLIPBOARD", true); - GDK_SELECTION_PRIMARY = intern("PRIMARY", true); - GDK_SELECTION_SECONDARY = intern("SECONDARY", true); + GDK_SELECTION_CLIPBOARD = Atom.intern("CLIPBOARD", true); + GDK_SELECTION_PRIMARY = Atom.intern("PRIMARY", true); + GDK_SELECTION_SECONDARY = Atom.intern("SECONDARY", true); } \ No newline at end of file diff --git a/source/gx/gtk/color.d b/source/gx/gtk/color.d index a1bbe8fd3..68d4bee90 100644 --- a/source/gx/gtk/color.d +++ b/source/gx/gtk/color.d @@ -9,7 +9,8 @@ import std.conv; import std.experimental.logger; import std.format; -import gdk.RGBA; +// GID imports - gdk +import gdk.rgba : RGBA; public: @@ -23,11 +24,11 @@ public: */ string rgbaTo8bitHex(RGBA color, bool includeAlpha = false, bool includeHash = false) { string prepend = includeHash ? "#" : ""; - int red = to!(int)(color.red() * 255); - int green = to!(int)(color.green() * 255); - int blue = to!(int)(color.blue() * 255); + int red = to!(int)(color.red * 255); + int green = to!(int)(color.green * 255); + int blue = to!(int)(color.blue * 255); if (includeAlpha) { - int alpha = to!(int)(color.alpha() * 255); + int alpha = to!(int)(color.alpha * 255); return prepend ~ format("%02X%02X%02X%02X", red, green, blue, alpha); } else { return prepend ~ format("%02X%02X%02X", red, green, blue); @@ -45,11 +46,11 @@ string rgbaTo8bitHex(RGBA color, bool includeAlpha = false, bool includeHash = f */ string rgbaTo16bitHex(RGBA color, bool includeAlpha = false, bool includeHash = false) { string prepend = includeHash ? "#" : ""; - int red = to!(int)(color.red() * 255); - int green = to!(int)(color.green() * 255); - int blue = to!(int)(color.blue() * 255); + int red = to!(int)(color.red * 255); + int green = to!(int)(color.green * 255); + int blue = to!(int)(color.blue * 255); if (includeAlpha) { - int alpha = to!(int)(color.alpha() * 255); + int alpha = to!(int)(color.alpha * 255); return prepend ~ format("%02X%02X%02X%02X%02X%02X%02X%02X", red, red, green, green, blue, blue, alpha, alpha); } else { return prepend ~ format("%02X%02X%02X%02X%02X%02X", red, red, green, green, blue, blue); diff --git a/source/gx/gtk/dialog.d b/source/gx/gtk/dialog.d index 53665b392..a8e26e8c6 100644 --- a/source/gx/gtk/dialog.d +++ b/source/gx/gtk/dialog.d @@ -4,12 +4,26 @@ */ module gx.gtk.dialog; -import gio.Settings: GSettings = Settings; +// GID imports - gio +import gio.settings : GSettings = Settings; -import gtk.CheckButton; -import gtk.Entry; -import gtk.MessageDialog; -import gtk.Window; +// GID imports - gobject +import gobject.object : ObjectWrap; + +// GID imports - gtk +import gtk.box : Box; +import gtk.check_button : CheckButton; +import gtk.c.functions : gtk_message_dialog_new; +import gtk.types : DialogFlags, MessageType, ButtonsType; +import gtk.c.types : GtkWidget, GtkWindow; +import gtk.editable : Editable; +import gtk.entry : Entry; +import gtk.message_dialog : MessageDialog; +import gtk.types : DialogFlags, MessageType, ButtonsType, ResponseType; +import gtk.widget : Widget; +import gtk.window : Window; + +import gid.gid : No; import gx.i18n.l10n; @@ -17,14 +31,23 @@ import gx.i18n.l10n; * Displays an error message in a dialog */ void showErrorDialog(Window parent, string message, string title = null) { - showMessageDialog(MessageType.ERROR, parent, message, title); + showMessageDialog(MessageType.Error, parent, message, title); } /** * Displays a message dialog of the specified type */ void showMessageDialog(MessageType mt, Window parent, string message, string title = null) { - MessageDialog dialog = new MessageDialog(parent, DialogFlags.MODAL + DialogFlags.USE_HEADER_BAR, mt, ButtonsType.OK, message, null); + DialogFlags flags = DialogFlags.Modal | DialogFlags.UseHeaderBar; + GtkWidget* widget = gtk_message_dialog_new( + parent ? cast(GtkWindow*) parent._cPtr(No.Dup) : null, + flags, + cast(MessageType) mt, + ButtonsType.Ok, + message.ptr, + null + ); + MessageDialog dialog = ObjectWrap._getDObject!MessageDialog(cast(void*) widget, No.Take); scope (exit) { dialog.destroy(); } @@ -40,36 +63,47 @@ alias OnValidate = bool delegate(string value); * Show an input dialog with a single entry for input */ bool showInputDialog(Window parent, out string value, string initialValue = "", string title = "", string message = "", OnValidate validate = null) { - MessageDialog dialog = new MessageDialog(parent, DialogFlags.MODAL + DialogFlags.USE_HEADER_BAR, MessageType.QUESTION, ButtonsType.OK_CANCEL, message, null); + DialogFlags flags = DialogFlags.Modal | DialogFlags.UseHeaderBar; + GtkWidget* widget = gtk_message_dialog_new( + parent ? cast(GtkWindow*) parent._cPtr(No.Dup) : null, + flags, + MessageType.Question, + ButtonsType.OkCancel, + message.ptr, + null + ); + MessageDialog dialog = ObjectWrap._getDObject!MessageDialog(cast(void*) widget, No.Take); scope (exit) { dialog.destroy(); } dialog.setTransientFor(parent); dialog.setTitle(title); - Entry entry; + Entry entry = new Entry(); if (initialValue.length > 0) { - entry = new Entry(initialValue); - } else { - entry = new Entry(); + entry.setText(initialValue); } - entry.addOnActivate(delegate(Entry) { - dialog.response(ResponseType.OK); + entry.connectActivate(delegate() { + dialog.response(ResponseType.Ok); }); if (validate !is null) { - entry.addOnChanged(delegate(EditableIF) { - if (validate(entry.getText)) { + entry.connectChanged(delegate() { + if (validate(entry.getText())) { entry.getStyleContext().removeClass("error"); - dialog.setResponseSensitive(ResponseType.OK, true); + dialog.setResponseSensitive(ResponseType.Ok, true); } else { entry.getStyleContext().addClass("error"); - dialog.setResponseSensitive(ResponseType.OK, false); + dialog.setResponseSensitive(ResponseType.Ok, false); } }); } - dialog.getMessageArea().add(entry); + Widget messageArea = dialog.getMessageArea(); + Box messageBox = cast(Box) messageArea; + if (messageBox !is null) { + messageBox.add(entry); + } entry.showAll(); - dialog.setDefaultResponse(ResponseType.OK); - if (dialog.run() == ResponseType.OK) { + dialog.setDefaultResponse(ResponseType.Ok); + if (dialog.run() == ResponseType.Ok) { value = entry.getText(); return true; } else { @@ -84,18 +118,26 @@ bool showInputDialog(Window parent, out string value, string initialValue = "", bool showConfirmDialog(Window parent, string message, GSettings settings = null, string promptKey = "") { if (settings !is null && !settings.getBoolean(promptKey)) return true; - MessageDialog dialog = new MessageDialog(parent, DialogFlags.MODAL + DialogFlags.USE_HEADER_BAR, MessageType.QUESTION, ButtonsType.OK_CANCEL, - message, null); - CheckButton cbPrompt = new CheckButton(_("Do not show this again")); - cbPrompt.setMarginLeft(12); + DialogFlags flags = DialogFlags.Modal | DialogFlags.UseHeaderBar; + GtkWidget* widget = gtk_message_dialog_new( + parent ? cast(GtkWindow*) parent._cPtr(No.Dup) : null, + flags, + MessageType.Question, + ButtonsType.OkCancel, + message.ptr, + null + ); + MessageDialog dialog = ObjectWrap._getDObject!MessageDialog(cast(void*) widget, No.Take); + CheckButton cbPrompt = CheckButton.newWithLabel(_("Do not show this again")); + cbPrompt.marginStart = 12; dialog.getContentArea().add(cbPrompt); - dialog.setDefaultResponse(ResponseType.CANCEL); + dialog.setDefaultResponse(ResponseType.Cancel); scope (exit) { dialog.destroy(); } dialog.showAll(); bool result = true; - if (dialog.run() != ResponseType.OK) { + if (dialog.run() != ResponseType.Ok) { result = false; } settings.setBoolean(promptKey, !cbPrompt.getActive()); diff --git a/source/gx/gtk/resource.d b/source/gx/gtk/resource.d index c552782ea..e10cc4668 100644 --- a/source/gx/gtk/resource.d +++ b/source/gx/gtk/resource.d @@ -10,21 +10,25 @@ import std.experimental.logger; import std.file; import std.path; -import gdk.Screen; +// GID imports - gdk +import gdk.screen : Screen; -import glib.Bytes; -import glib.GException; -import glib.Util; +// GID imports - gio +import gio.global : resourcesLookupData, resourcesRegister; +import gio.resource : Resource; +import gio.types : ResourceLookupFlags; -import gio.Resource; +// GID imports - glib +import glib.bytes : Bytes; +import glib.error : ErrorWrap; +import glib.global : getSystemDataDirs, getUserDataDir; -import gtk.CssProvider; -import gtk.StyleContext; - -import gtkc.giotypes; +// GID imports - gtk +import gtk.css_provider : CssProvider; +import gtk.style_context : StyleContext; /** - * Defined here since not defined in GtkD + * Provider priority values for CSS styling */ enum ProviderPriority : uint { FALLBACK = 1, @@ -38,14 +42,16 @@ enum ProviderPriority : uint { * Find and optionally register a resource */ Resource findResource(string resourcePath, bool register = true) { - foreach (path; Util.getSystemDataDirs()) { + // Search in user data dir first, then system data dirs + string[] searchPaths = [getUserDataDir()] ~ getSystemDataDirs(); + foreach (path; searchPaths) { auto fullpath = buildPath(path, resourcePath); trace("looking for resource " ~ fullpath); if (exists(fullpath)) { Resource resource = Resource.load(fullpath); if (register && resource) { trace("Resource found and registered " ~ fullpath); - Resource.register(resource); + resourcesRegister(resource); } return resource; } @@ -59,11 +65,11 @@ CssProvider createCssProvider(string filename, string[string] variables = null) CssProvider provider = new CssProvider(); string css = getResource(filename, variables); if (css.length > 0) { - if (provider.loadFromData(css)) { + if (provider.loadFromData(cast(ubyte[]) css)) { return provider; } } - } catch (GException ge) { + } catch (ErrorWrap ge) { trace("Unexpected error loading css provider " ~ filename); trace("Error: " ~ ge.msg); } @@ -80,14 +86,14 @@ CssProvider addCssProvider(string filename, ProviderPriority priority, string[st if (provider !is null) { Screen screen = Screen.getDefault(); if (screen !is null) { - StyleContext.addProviderForScreen(Screen.getDefault(), provider, priority); + StyleContext.addProviderForScreen(screen, provider, priority); return provider; } else { warning("Default screen is null, no CSS provider added and as a result Tilix UI may appear incorrect"); return null; } } - } catch (GException ge) { + } catch (ErrorWrap ge) { trace("Unexpected error loading css provider " ~ filename); trace("Error: " ~ ge.msg); } @@ -100,13 +106,14 @@ CssProvider addCssProvider(string filename, ProviderPriority priority, string[st string getResource(string filename, string[string] variables = null) { Bytes bytes; try { - bytes = Resource.resourcesLookupData(filename, GResourceLookupFlags.NONE); - } catch (GException ge) { + bytes = resourcesLookupData(filename, ResourceLookupFlags.None); + } catch (ErrorWrap ge) { return null; } if (bytes is null || bytes.getSize() == 0) return null; else { - string contents = to!string(cast(char*)bytes.getData()); + ubyte[] data = bytes.getData(); + string contents = to!string(cast(char[]) data); if (variables !is null) { foreach(variable; variables.byKeyValue()) { contents = contents.replace(variable.key, variable.value); @@ -114,4 +121,4 @@ string getResource(string filename, string[string] variables = null) { } return contents; } -} +} \ No newline at end of file diff --git a/source/gx/gtk/settings.d b/source/gx/gtk/settings.d index e1fc37f3d..c3f06e235 100644 --- a/source/gx/gtk/settings.d +++ b/source/gx/gtk/settings.d @@ -6,10 +6,12 @@ module gx.gtk.settings; import std.experimental.logger; -import gtkc.giotypes; +// GID imports - gio +import gio.settings : GSettings = Settings; +import gio.types : SettingsBindFlags; -import gobject.ObjectG; -import gio.Settings: GSettings = Settings; +// GID imports - gobject +import gobject.object : ObjectWrap; /** * Bookkeeping class that keps track of objects which are @@ -35,7 +37,7 @@ private: /** * Adds a binding to the list */ - void addBind(string key, ObjectG object, string property, GSettingsBindFlags flags) { + void addBind(string key, ObjectWrap object, string property, SettingsBindFlags flags) { bindings ~= Binding(key, object, property, flags); } @@ -71,7 +73,7 @@ public: /** * Add a binding to list and binds to Settings if it is set. */ - void bind(string key, ObjectG object, string property, GSettingsBindFlags flags) { + void bind(string key, ObjectWrap object, string property, SettingsBindFlags flags) { addBind(key, object, property, flags); if (settings !is null) { _settings.bind(key, object, property, flags); @@ -83,7 +85,7 @@ public: */ void unbind() { foreach(binding; bindings) { - _settings.unbind(binding.object, binding.property); + GSettings.unbind(binding.object, binding.property); } } @@ -100,7 +102,7 @@ private: struct Binding { string key; - ObjectG object; + ObjectWrap object; string property; - GSettingsBindFlags flags; -} + SettingsBindFlags flags; +} \ No newline at end of file diff --git a/source/gx/gtk/threads.d b/source/gx/gtk/threads.d index 6f420507f..c9d302d67 100644 --- a/source/gx/gtk/threads.d +++ b/source/gx/gtk/threads.d @@ -4,190 +4,71 @@ */ module gx.gtk.threads; -import core.memory; - -import std.algorithm; import std.experimental.logger; -import std.stdio; - -import gdk.Threads; - -/** - * Simple structure that contains a pointer to a delegate. This is necessary because delegates are not directly - * convertable to a simple pointer (which is needed to pass as data to a C callback). - * - * This code from grestful (https://github.com/Gert-dev/grestful) - */ -struct DelegatePointer(S, U...) -{ - S delegateInstance; - - U parameters; - - /** - * Constructor. - * - * @param delegateInstance The delegate to invoke. - * @param parameters The parameters to pass to the delegate. - */ - public this(S delegateInstance, U parameters) - { - this.delegateInstance = delegateInstance; - this.parameters = parameters; - } -} -/** - * Callback that will invoke the passed DelegatePointer's delegate when it is called. This very useful method can be - * used to pass delegates to gdk.Threads.threadsAddIdle instead of having to define a callback with C linkage and a - * different method for every different action. - * - * The return type is the type that should be returned by this function. The invoked delegate should as a best practice - * return the same value. If an exception happens and the value from the delegate can't be returned, the '.init' value - * of the type will be used instead (or nothing in the case of void). - * - * Finally, if doRemoveRoot is set to true, this function will execute a removeRoot on the garbage collector for the - * passed data (which is the delegate). This is useful in situations where you're passing a delegate to a C function - * that will happen asynchronously, in which case you should be adding the newly allocated DelegatePointer using - * addRoot to ensure the garbage collector doesn't attempt to collect the delegate while the callback hasn't been - * invoked yet. - * - * @param data The data that is passed to the method. - * - * @return Whether or not the method should continue executing. - * - * This code from grestful (https://github.com/Gert-dev/grestful) - */ -extern(C) nothrow static ReturnType invokeDelegatePointerFunc(S, ReturnType, bool doRemoveRoot = false)(void* data) -{ - auto callbackPointer = cast(S*) data; - - try - { - static if (__traits(compiles, ReturnType.init)) - { - auto returnValue = callbackPointer.delegateInstance(callbackPointer.parameters); - return returnValue; - } - - else - { - callbackPointer.delegateInstance(callbackPointer.parameters); - } - } +// GID imports - gdk +import gdk.global : threadsAddIdle, threadsAddTimeout; - catch (Exception e) - { - // Just catch it, can't throw D exceptions accross C boundaries. - static if (__traits(compiles, ReturnType.init)) - return ReturnType.init; - } - - // Should only end up here for types that don't have an initial value (such as void). -} +// GID imports - glib +import glib.types : SourceFunc, PRIORITY_DEFAULT_IDLE; /** - * Convenience method that allows scheduling a delegate to be executed with gdk.Threads.threadsAddIdle instead of a - * traditional callback with C linkage. + * Convenience method that allows scheduling a delegate to be executed with gdk.global.threadsAddIdle. + * The delegate should return true to be called again, or false to stop. * * @param theDelegate The delegate to schedule. * @param parameters A tuple of parameters to pass to the delegate when it is invoked. * * @example - * auto myMethod = delegate(string name, string value) { do_something_with_name_and_value(); } + * auto myMethod = delegate(string name, string value) { do_something_with_name_and_value(); return false; } * threadsAddIdleDelegate(myMethod, "thisIsAName", "thisIsAValue"); - * - * This code from grestful (https://github.com/Gert-dev/grestful) */ void threadsAddIdleDelegate(T, parameterTuple...)(T theDelegate, parameterTuple parameters) { - void* delegatePointer = null; - - auto wrapperDelegate = (parameterTuple parameters) { - bool callAgainNextIdleCycle = false; - - try - { - callAgainNextIdleCycle = theDelegate(parameters); - //if (callAgainNextIdleCycle) trace("Callback again is true"); - //else trace("Callback again is false"); - } - - catch (Exception e) - { - warning("Unexpected exception occurred in wrapper"); - // Catch exceptions here as otherwise, memory may never be freed below. - } - - if (!callAgainNextIdleCycle) { - //trace("Removing delegate pointer"); - GC.removeRoot(delegatePointer); - return false; - } else return true; - }; - - delegatePointer = cast(void*) new DelegatePointer!(T, parameterTuple)(wrapperDelegate, parameters); - - // We're going into a separate thread and exiting here, make sure the garbage collector doesn't think the memory - // isn't used anymore and collects it. - GC.addRoot(delegatePointer); - - gdk.Threads.threadsAddIdle( - cast(GSourceFunc) &invokeDelegatePointerFunc!(DelegatePointer!(T, parameterTuple), int), - delegatePointer - ); + // Wrap the user's delegate in a SourceFunc (bool delegate()) + SourceFunc wrappedDelegate = delegate bool() { + try + { + return theDelegate(parameters); + } + catch (Exception e) + { + warning("Unexpected exception occurred in idle callback: " ~ e.msg); + return false; + } + }; + + threadsAddIdle(PRIORITY_DEFAULT_IDLE, wrappedDelegate); } /** - * Convenience method that allows scheduling a delegate to be executed with gdk.Threads.threadsAddTimeout instead of a - * traditional callback with C linkage. + * Convenience method that allows scheduling a delegate to be executed with gdk.global.threadsAddTimeout. + * The delegate should return true to be called again, or false to stop. * * @param interval The interval to call the delegate in ms * @param theDelegate The delegate to schedule. * @param parameters A tuple of parameters to pass to the delegate when it is invoked. * * @example - * auto myMethod = delegate(string name, string value) { do_something_with_name_and_value(); } - * threadsAddIdleDelegate(myMethod, "thisIsAName", "thisIsAValue"); + * auto myMethod = delegate(string name, string value) { do_something_with_name_and_value(); return false; } + * threadsAddTimeoutDelegate(1000, myMethod, "thisIsAName", "thisIsAValue"); * - * This code from grestful (https://github.com/Gert-dev/grestful) + * @return The ID of the event source. */ uint threadsAddTimeoutDelegate(T, parameterTuple...)(uint interval, T theDelegate, parameterTuple parameters) { - void* delegatePointer = null; - - auto wrapperDelegate = (parameterTuple parameters) { - bool callAgainNextIdleCycle = false; - - try - { - callAgainNextIdleCycle = theDelegate(parameters); - //if (callAgainNextIdleCycle) trace("Callback again is true"); - //else trace("Callback again is false"); - } - - catch (Exception e) - { - warning("Unexpected exception occurred in wrapper"); - // Catch exceptions here as otherwise, memory may never be freed below. - } - - if (!callAgainNextIdleCycle) { - //trace("Removing delegate pointer"); - GC.removeRoot(delegatePointer); - return false; - } else return true; - }; - - delegatePointer = cast(void*) new DelegatePointer!(T, parameterTuple)(wrapperDelegate, parameters); - - // We're going into a separate thread and exiting here, make sure the garbage collector doesn't think the memory - // isn't used anymore and collects it. - GC.addRoot(delegatePointer); - - return gdk.Threads.threadsAddTimeout( - interval, - cast(GSourceFunc) &invokeDelegatePointerFunc!(DelegatePointer!(T, parameterTuple), int), - delegatePointer - ); -} + // Wrap the user's delegate in a SourceFunc (bool delegate()) + SourceFunc wrappedDelegate = delegate bool() { + try + { + return theDelegate(parameters); + } + catch (Exception e) + { + warning("Unexpected exception occurred in timeout callback: " ~ e.msg); + return false; + } + }; + + return threadsAddTimeout(PRIORITY_DEFAULT_IDLE, interval, wrappedDelegate); +} \ No newline at end of file diff --git a/source/gx/gtk/util.d b/source/gx/gtk/util.d index 8876004b6..3bd02fe86 100644 --- a/source/gx/gtk/util.d +++ b/source/gx/gtk/util.d @@ -4,91 +4,125 @@ */ module gx.gtk.util; +import gid.gid : No, Yes; + import std.conv; import std.experimental.logger; import std.format; import std.process; import std.string; -import gdk.Atom; -import gdk.Gdk; -import gdk.RGBA; -import gdk.X11; - -import gio.FileIF; -import gio.ListModelIF; -import gio.Settings: GSettings = Settings; - -import glib.GException; -import glib.ListG; -import glib.Str; - -import gobject.ObjectG; -import gobject.Type; -import gobject.TypeInstance; -import gobject.Value; - -import gtk.Bin; -import gtk.Box; -import gtk.ComboBox; -import gtk.CellRendererText; -import gtk.Container; -import gtk.Entry; -import gtk.ListStore; -import gtk.Main; -import gtk.Paned; -import gtk.Settings; -import gtk.StyleContext; -import gtk.TreeIter; -import gtk.TreeModelIF; -import gtk.TreePath; -import gtk.TreeStore; -import gtk.TreeView; -import gtk.TreeViewColumn; -import gtk.Widget; -import gtk.Window; +// GID imports - gdk +import gdk.atom; +import gdk.rgba : RGBA; + +// GID imports - gio +import gio.file : File; +import gio.list_model : ListModel; +import gio.settings : Settings; +import gio.c.functions : g_file_parse_name, g_settings_get_strv; +import gio.c.types : GFile, GSettings; + +// GID imports - glib +import glib.error : ErrorWrap; + +// GID imports - gobject +import gobject.object : ObjectWrap; +import gobject.value : Value; +import gobject.c.functions : g_type_check_instance_is_a; +import gobject.c.types : GType, GTypeInstance; + +// GID imports - gtk +import gtk.bin : Bin; +import gtk.box : Box; +import gtk.combo_box : ComboBox; +import gtk.cell_renderer_text : CellRendererText; +import gtk.container : Container; +import gtk.entry : Entry; +import gtk.list_store : ListStore; +import gtk.global : eventsPending, mainIterationDo; +import gtk.paned : Paned; +import gtk.settings : GtkSettings = Settings; +import gtk.style_context : StyleContext; +import gtk.tree_iter : TreeIter; +import gtk.tree_model : TreeModel; +import gtk.tree_path : TreePath; +import gtk.tree_store : TreeStore; +import gtk.tree_view : TreeView; +import gtk.tree_view_column : TreeViewColumn; +import gtk.widget : Widget; +import gtk.window : Window; +import gtk.types : Orientation, StateFlags; import gx.gtk.x11; /** - * Parse filename and return FileIF object + * Parse filename and return File object */ -public FileIF parseName(string parseName) { - import gio.c.functions; - auto p = g_file_parse_name(Str.toStringz(parseName)); +public File parseName(string parseName) { + auto p = g_file_parse_name(parseName.ptr); - if(p is null) { + if (p is null) { return null; } - return ObjectG.getDObject!(FileIF)(cast(GFile*) p, true); + return ObjectWrap._getDObject!File(p, Yes.Take); } +/** + * Workaround for GID 0.9.7 bug in Settings.getStrv where the loop + * counting array length has an erroneous 'break' statement, causing + * it to return at most 1 element instead of all elements. + * + * This function correctly retrieves all string array elements. + */ +string[] getSettingsStrv(Settings settings, string key) { + import std.string : fromStringz; + char** cretval = g_settings_get_strv(cast(GSettings*)settings._cPtr(No.Dup), key.ptr); + string[] result; + + if (cretval !is null) { + // Correctly count all elements (no erroneous break) + size_t length = 0; + while (cretval[length] !is null) { + length++; + } + + result = new string[length]; + foreach (i; 0 .. length) { + result[i] = cast(string) fromStringz(cretval[i]); + } + } + + return result; +} /** * Directly process events for up to a specified period */ -static if (__VERSION__ >=2075) { +static if (__VERSION__ >= 2075) { void processEvents(uint millis) { - import std.datetime.stopwatch: StopWatch, AutoStart; + import std.datetime.stopwatch : StopWatch, AutoStart; + StopWatch sw = StopWatch(AutoStart.yes); scope (exit) { sw.stop(); } - while (gtk.Main.Main.eventsPending() && sw.peek.total!"msecs" < millis) { - Main.iterationDo(false); + while (eventsPending() && sw.peek.total!"msecs" < millis) { + mainIterationDo(false); } } } else { void processEvents(uint millis) { - import std.datetime: StopWatch, AutoStart; + import std.datetime : StopWatch, AutoStart; + StopWatch sw = StopWatch(AutoStart.yes); scope (exit) { sw.stop(); } - while (gtk.Main.Main.eventsPending() && sw.peek().msecs < millis) { - Main.iterationDo(false); + while (eventsPending() && sw.peek().msecs < millis) { + mainIterationDo(false); } } } @@ -97,7 +131,8 @@ static if (__VERSION__ >=2075) { * Activates a window using the X11 APIs when available */ void activateWindow(Window window) { - if (window.isActive()) return; + if (window.isActive()) + return; if (isWayland(window)) { trace("Present Window for Wayland"); @@ -114,15 +149,19 @@ void activateWindow(Window window) { * it just uses a simple environment variable check to detect it. */ bool isWayland(Window window) { - if (window is null || window.getWindow() is null) { - return (environment.get("XDG_SESSION_TYPE","x11") == "wayland" && environment.get("GDK_BACKEND")!="x11"); + import gdk.window : GdkWindow = Window; + + if (window is null) { + return (environment.get("XDG_SESSION_TYPE", "x11") == "wayland" && environment.get("GDK_BACKEND") != "x11"); } - import gtkc.gdk: gdk_x11_window_get_type; - import gtkc.gobject: g_type_check_instance_is_a; + GdkWindow gdkWin = window.getWindow(); + if (gdkWin is null) { + return (environment.get("XDG_SESSION_TYPE", "x11") == "wayland" && environment.get("GDK_BACKEND") != "x11"); + } - GType x11Type = gdk_x11_window_get_type(); - GTypeInstance* instance = cast(GTypeInstance*)(window.getWindow().getObjectGStruct()); + GType x11Type = getX11WindowType(); + GTypeInstance* instance = cast(GTypeInstance*)(gdkWin._cPtr); return g_type_check_instance_is_a(instance, x11Type) == 0; } @@ -131,17 +170,16 @@ bool isWayland(Window window) { * Return the name of the GTK Theme */ string getGtkTheme() { - Value value = new Value(""); - Settings.getDefault.getProperty("gtk-theme-name", value); - return value.getString(); + auto settings = GtkSettings.getDefault(); + return settings.gtkThemeName; } /** * Convenience method for creating a box and adding children */ -Box createBox(Orientation orientation, int spacing, Widget[] children) { +Box createBox(Orientation orientation, int spacing, Widget[] children) { Box result = new Box(orientation, spacing); - foreach(child; children) { + foreach (child; children) { result.add(child); } return result; @@ -151,9 +189,10 @@ Box createBox(Orientation orientation, int spacing, Widget[] children) { * Finds the index position of a child in a container. */ int getChildIndex(Container container, Widget child) { - Widget[] children = container.getChildren().toArray!Widget(); - foreach(i, c; children) { - if (c.getWidgetStruct() == child.getWidgetStruct()) return cast(int) i; + auto children = container.getChildren(); + foreach (i, c; children) { + if (c._cPtr == child._cPtr) + return cast(int) i; } return -1; } @@ -162,11 +201,12 @@ int getChildIndex(Container container, Widget child) { * Walks up the parent chain until it finds the parent of the * requested type. */ -T findParent(T) (Widget widget) { +T findParent(T)(Widget widget) { while ((widget !is null)) { widget = widget.getParent(); T result = cast(T) widget; - if (result !is null) return result; + if (result !is null) + return result; } return null; } @@ -174,29 +214,31 @@ T findParent(T) (Widget widget) { /** * Template for finding all children of a specific type */ -T[] getChildren(T) (Widget widget, bool recursive) { +T[] findChildren(T)(Widget widget, bool recursive) { T[] result; Widget[] children; - if (widget is null) return result; + if (widget is null) + return result; Bin bin = cast(Bin) widget; if (bin !is null) { - children = [bin.getChild()]; + auto child = bin.getChild(); + if (child !is null) + children = [child]; } else { Container container = cast(Container) widget; if (container !is null) { - ListG list = container.getChildren(); - if (list !is null) - children = list.toArray!(Widget)(); + children = container.getChildren(); } } - foreach(child; children) { + foreach (child; children) { T match = cast(T) child; - if (match !is null) result ~= match; + if (match !is null) + result ~= match; if (recursive) { - result ~= getChildren!(T)(child, recursive); + result ~= findChildren!(T)(child, recursive); } } return result; @@ -241,23 +283,23 @@ void setAllMargins(Widget widget, int margin) { * Sets margins of a widget to the passed values */ void setMargins(Widget widget, int left, int top, int right, int bottom) { - widget.setMarginLeft(left); - widget.setMarginTop(top); - widget.setMarginRight(right); - widget.setMarginBottom(bottom); + widget.marginStart = left; + widget.marginTop = top; + widget.marginEnd = right; + widget.marginBottom = bottom; } /** - * Defined here since not defined in GtkD + * Defined here since not defined in GID */ enum MouseButton : uint { - PRIMARY = 1, - MIDDLE = 2, - SECONDARY = 3 + Primary = 1, + Middle = 2, + Secondary = 3 } /** - * Not declared in GtkD + * Not declared in GID */ enum long GDK_CURRENT_TIME = 0; @@ -277,46 +319,57 @@ bool equal(Widget w1, Widget w2) { return true; if ((w1 is null && w2 !is null) || (w1 !is null && w2 is null)) return false; - return w1.getWidgetStruct() == w2.getWidgetStruct(); + return w1._cPtr == w2._cPtr; } /** - * Appends multiple values to a row in a list store + * Appends multiple values to a row in a tree store */ TreeIter appendValues(TreeStore ts, TreeIter parentIter, string[] values) { - TreeIter iter = ts.createIter(parentIter); + TreeIter iter; + ts.append(iter, parentIter); for (int i = 0; i < values.length; i++) { - ts.setValue(iter, i, values[i]); + ts.setValue(iter, i, new Value(values[i])); } return iter; } - /** * Appends multiple values to a row in a list store */ TreeIter appendValues(ListStore ls, string[] values) { - TreeIter iter = ls.createIter(); + TreeIter iter; + ls.append(iter); for (int i = 0; i < values.length; i++) { - ls.setValue(iter, i, values[i]); + ls.setValue(iter, i, new Value(values[i])); } return iter; } +/** + * GType constants for common types + */ +enum GTypes : GType { + STRING = 64, // G_TYPE_STRING + BOOLEAN = 20, // G_TYPE_BOOLEAN + INT = 24, // G_TYPE_INT + INT64 = 40, // G_TYPE_INT64 + DOUBLE = 60 // G_TYPE_DOUBLE +} + /** * Creates a combobox that holds a set of name/value pairs * where the name is displayed. */ ComboBox createNameValueCombo(const string[string] keyValues) { - - ListStore ls = new ListStore([GType.STRING, GType.STRING]); + ListStore ls = ListStore.new_([GTypes.STRING, GTypes.STRING]); foreach (key, value; keyValues) { appendValues(ls, [value, key]); } - ComboBox cb = new ComboBox(ls, false); - cb.setFocusOnClick(false); - cb.setIdColumn(1); + ComboBox cb = ComboBox.newWithModel(ls); + cb.focusOnClick = false; + cb.idColumn = 1; CellRendererText cell = new CellRendererText(); cell.setAlignment(0, 0); cb.packStart(cell, false); @@ -332,15 +385,15 @@ ComboBox createNameValueCombo(const string[string] keyValues) { ComboBox createNameValueCombo(const string[] names, const string[] values) { assert(names.length == values.length); - ListStore ls = new ListStore([GType.STRING, GType.STRING]); + ListStore ls = ListStore.new_([GTypes.STRING, GTypes.STRING]); for (int i = 0; i < names.length; i++) { appendValues(ls, [names[i], values[i]]); } - ComboBox cb = new ComboBox(ls, false); - cb.setFocusOnClick(false); - cb.setIdColumn(1); + ComboBox cb = ComboBox.newWithModel(ls); + cb.focusOnClick = false; + cb.idColumn = 1; CellRendererText cell = new CellRendererText(); cell.setAlignment(0, 0); cb.packStart(cell, false); @@ -355,26 +408,32 @@ template TComboBox(T) { assert(names.length == values.length); trace(typeof(values).stringof); - GType valueType = GType.STRING; - if (is(typeof(values) == int[])) valueType = GType.INT; - else if (is(typeof(values) == uint[])) valueType = GType.INT; - else if (is(typeof(values) == long[])) valueType = GType.INT64; - else if (is(typeof(values) == ulong[])) valueType = GType.INT64; - else if (is(typeof(values) == double[])) valueType = GType.DOUBLE; + GType valueType = GTypes.STRING; + if (is(typeof(values) == int[])) + valueType = GTypes.INT; + else if (is(typeof(values) == uint[])) + valueType = GTypes.INT; + else if (is(typeof(values) == long[])) + valueType = GTypes.INT64; + else if (is(typeof(values) == ulong[])) + valueType = GTypes.INT64; + else if (is(typeof(values) == double[])) + valueType = GTypes.DOUBLE; trace(valueType); - ListStore ls = new ListStore([GType.STRING, valueType]); + ListStore ls = ListStore.new_([GTypes.STRING, valueType]); for (int row; row < values.length; row++) { - TreeIter iter = ls.createIter(); - ls.setValue(iter, 0, names[row]); - ls.setValue(iter, 1, values[row]); + TreeIter iter; + ls.append(iter); + ls.setValue(iter, 0, new Value(names[row])); + ls.setValue(iter, 1, new Value(values[row])); } - ComboBox cb = new ComboBox(ls, false); - cb.setFocusOnClick(false); - cb.setIdColumn(1); + ComboBox cb = ComboBox.newWithModel(ls); + cb.focusOnClick = false; + cb.idColumn = 1; CellRendererText cell = new CellRendererText(); cell.setAlignment(0, 0); cb.packStart(cell, false); @@ -387,10 +446,9 @@ template TComboBox(T) { * Selects the specified row in a Treeview */ void selectRow(TreeView tv, int row, TreeViewColumn column = null) { - TreeModelIF model = tv.getModel(); + TreeModel model = tv.getModel(); TreeIter iter; - model.iterNthChild(iter, null, row); - if (iter !is null) { + if (model.iterNthChild(iter, null, row)) { tv.setCursor(model.getPath(iter), column, false); } else { tracef("No TreeIter found for row %d", row); @@ -403,20 +461,21 @@ void selectRow(TreeView tv, int row, TreeViewColumn column = null) { struct TreeIterRange { private: - TreeModelIF model; + TreeModel model; TreeIter iter; bool _empty; public: - this(TreeModelIF model) { + this(TreeModel model) { this.model = model; _empty = !model.getIterFirst(iter); } - this(TreeModelIF model, TreeIter parent) { + this(TreeModel model, TreeIter parent) { this.model = model; _empty = !model.iterChildren(iter, parent); - if (_empty) trace("TreeIter has no children"); + if (_empty) + trace("TreeIter has no children"); } @property bool empty() { @@ -436,7 +495,6 @@ public: */ int opApply(int delegate(ref TreeIter iter) dg) { int result = 0; - //bool hasNext = model.getIterFirst(iter); bool hasNext = !_empty; while (hasNext) { result = dg(iter); @@ -448,3 +506,86 @@ public: return result; } } + +/** + * Helper function to get a string value from a TreeModel at the given column + */ +string getValueString(TreeModel model, TreeIter iter, int column) { + Value val; + model.getValue(iter, column, val); + if (val is null) return ""; + return val.getString(); +} + +/** + * Helper function to get a string value from a TreeStore at the given column + */ +string getValueString(TreeStore store, TreeIter iter, int column) { + return getValueString(cast(TreeModel) store, iter, column); +} + +/** + * Helper function to get a string value from a ListStore at the given column + */ +string getValueString(ListStore store, TreeIter iter, int column) { + return getValueString(cast(TreeModel) store, iter, column); +} + +/** + * Helper function to get an int value from a TreeModel at the given column + */ +int getValueInt(TreeModel model, TreeIter iter, int column) { + Value val; + model.getValue(iter, column, val); + if (val is null) return 0; + return val.getInt(); +} + +/** + * Helper function to get an int value from a TreeStore at the given column + */ +int getValueInt(TreeStore store, TreeIter iter, int column) { + return getValueInt(cast(TreeModel) store, iter, column); +} + +/** + * Helper function to get an int value from a ListStore at the given column + */ +int getValueInt(ListStore store, TreeIter iter, int column) { + return getValueInt(cast(TreeModel) store, iter, column); +} + +/** + * Helper function to get the selected TreeIter from a TreeView + * Returns null if nothing is selected + */ +TreeIter getSelectedIter(TreeView tv) { + import gtk.tree_selection : TreeSelection; + TreeSelection selection = tv.getSelection(); + if (selection is null) return null; + TreeModel model; + TreeIter iter; + if (selection.getSelected(model, iter)) { + return iter; + } + return null; +} + +/** + * Helper function to check if a TreeIter has a parent + */ +bool hasParent(TreeModel model, TreeIter iter) { + TreeIter parent; + return model.iterParent(parent, iter); +} + +/** + * Helper function to get parent iter + */ +TreeIter getParentIter(TreeModel model, TreeIter iter) { + TreeIter parent; + if (model.iterParent(parent, iter)) { + return parent; + } + return null; +} \ No newline at end of file diff --git a/source/gx/gtk/vte.d b/source/gx/gtk/vte.d index 88d444000..6261bdf3b 100644 --- a/source/gx/gtk/vte.d +++ b/source/gx/gtk/vte.d @@ -7,12 +7,21 @@ module gx.gtk.vte; import std.experimental.logger; import std.format; -import gdk.Keysyms; +// GID imports - gdk +import gdk.types : KEY_Page_Up, KEY_Page_Down, KEY_Home, KEY_End, KEY_Up, KEY_Down; +import gdk.c.types : GdkModifierType; -import gobject.Signals: Signals; +// GID imports - gobject +import gobject.global : signalLookup; -import vte.Terminal; -import vte.Version; +// GID imports - gdk +import gdk.rgba : RGBA; +import vte.c.types : GdkRGBA, VteTerminal; + +// GID imports - vte +import vte.c.functions : vte_terminal_new, vte_terminal_set_colors; +import vte.global : getMajorVersion, getMinorVersion; +import vte.terminal : Terminal; // Constants used to version VTE features int[2] VTE_VERSION_MINIMAL = [0, 46]; @@ -57,16 +66,16 @@ enum PCRE2Flags : uint { * that VTE handles internally. */ bool isVTEHandledKeystroke(uint keyval, GdkModifierType modifier) { - if ((keyval == GdkKeysyms.GDK_Page_Up || - keyval == GdkKeysyms.GDK_Page_Down || - keyval == GdkKeysyms.GDK_Home || - keyval == GdkKeysyms.GDK_End) && (GdkModifierType.SHIFT_MASK & modifier)) { + if ((keyval == KEY_Page_Up || + keyval == KEY_Page_Down || + keyval == KEY_Home || + keyval == KEY_End) && (GdkModifierType.ShiftMask & modifier)) { return true; } - if ((keyval == GdkKeysyms.GDK_Up || - keyval == GdkKeysyms.GDK_Down) && - (GdkModifierType.SHIFT_MASK & modifier) && - (GdkModifierType.CONTROL_MASK & modifier)) { + if ((keyval == KEY_Up || + keyval == KEY_Down) && + (GdkModifierType.ShiftMask & modifier) && + (GdkModifierType.ControlMask & modifier)) { return true; } return false; @@ -102,38 +111,27 @@ private static bool g_vteTerminalLoaded = false; * Determine which terminal features are supported. */ bool checkVTEFeature(TerminalFeature feature) { - // Initialized features if not done yet, can't do it statically + // Initialize features if not done yet, can't do it statically // due to need for GTK to load first if (!featuresInitialized) { - import vte.c.functions; - // Force terminal to be loaded if not done already if (!g_vteTerminalLoaded) { g_vteTerminalLoaded = true; - auto terminal = vte_terminal_new (); + auto terminal = vte_terminal_new(); } // Check if patched events are available string[] events = ["notification-received", "terminal-screen-changed"]; - foreach(i, event; events) { - bool supported = (Signals.lookup(event, Terminal.getType()) != 0); + foreach (i, event; events) { + bool supported = (signalLookup(event, Terminal._getGType()) != 0); terminalFeatures[cast(TerminalFeature) i] = supported; } // Check if disable background draw is available - terminalFeatures[TerminalFeature.DISABLE_BACKGROUND_DRAW] = true; + // In GID we can't easily check for symbol load failures like GtkD's Linker, + // so we rely on version checking instead + terminalFeatures[TerminalFeature.DISABLE_BACKGROUND_DRAW] = checkVTEVersion(VTE_VERSION_BACKGROUND_OPERATOR); - import gtkc.Loader: Linker; - import gtkc.paths: LIBRARY; - string[] failures = Linker.getLoadFailures(LIBRARY_VTE); - - foreach(failure; failures) { - if (failure == "vte_terminal_get_disable_bg_draw") { - trace("Background draw disabled"); - terminalFeatures[TerminalFeature.DISABLE_BACKGROUND_DRAW] = false; - } - tracef("VTE function %s could not be linked", failure); - } featuresInitialized = true; } if (feature in terminalFeatures) { @@ -147,6 +145,38 @@ bool isVTEBackgroundDrawEnabled() { return checkVTEFeature(TerminalFeature.DISABLE_BACKGROUND_DRAW) || checkVTEVersion(VTE_VERSION_BACKGROUND_OPERATOR); } +/** + * Workaround for GID VTE binding bug where palette RGBA array is not + * correctly passed to vte_terminal_set_colors. The GID binding uses + * obj._cPtr instead of obj._cPtr() for palette elements, getting a + * delegate instead of calling the method. + * + * This function correctly builds the GdkRGBA array and calls the C function. + */ +void setTerminalColors(Terminal terminal, RGBA foreground, RGBA background, RGBA[] palette) { + import gid.gid : No; + + // Build palette array correctly + GdkRGBA[] paletteArray; + if (palette !is null) { + paletteArray = new GdkRGBA[palette.length]; + foreach (i, rgba; palette) { + if (rgba !is null) { + paletteArray[i] = *cast(GdkRGBA*)rgba._cPtr(No.Dup); + } + } + } + + // Call VTE C function directly + vte_terminal_set_colors( + cast(VteTerminal*)terminal._cPtr(No.Dup), + foreground ? cast(const(GdkRGBA)*)foreground._cPtr(No.Dup) : null, + background ? cast(const(GdkRGBA)*)background._cPtr(No.Dup) : null, + paletteArray.length > 0 ? paletteArray.ptr : null, + paletteArray.length + ); +} + private: uint vteMajorVersion = 0; @@ -158,11 +188,11 @@ bool[TerminalFeature] terminalFeatures; static this() { // Get version numbers try { - vteMajorVersion = Version.getMajorVersion(); - vteMinorVersion = Version.getMinorVersion(); + vteMajorVersion = getMajorVersion(); + vteMinorVersion = getMinorVersion(); } catch (Error e) { - //Ignore, means VTE doesn't support version API, default to 46 + // Ignore, means VTE doesn't support version API, default to 46 } } @@ -181,7 +211,7 @@ unittest { assert(!checkVTEVersionNumber(1, 1)); assert(checkVTEVersionNumber(0, 9)); - vteMajorVersion = Version.getMajorVersion(); - vteMinorVersion = Version.getMinorVersion(); + vteMajorVersion = getMajorVersion(); + vteMinorVersion = getMinorVersion(); assert(checkVTEVersion(VTE_VERSION_MINIMAL)); -} +} \ No newline at end of file diff --git a/source/gx/gtk/x11.d b/source/gx/gtk/x11.d index b33f03a54..324c4789a 100644 --- a/source/gx/gtk/x11.d +++ b/source/gx/gtk/x11.d @@ -17,23 +17,23 @@ module gx.gtk.x11; +import core.sys.posix.dlfcn : dlopen, dlsym, RTLD_NOW, RTLD_GLOBAL; import std.experimental.logger; import std.string; -import gtkc.glibtypes; +// GID imports - gdk +import gdk.global : errorTrapPop, errorTrapPush, flush; +import gdk.window : GdkWindow = Window; +import gdk.c.types : GdkWindow_ = GdkWindow; -import gtkc.Loader; -import gtkc.paths; +// GID imports - gtk +import gtk.global : getCurrentEventTime; +import gtk.window : Window; -import gdk.Atom; -import gdk.Gdk; -import gdk.X11; +import gid.gid : No; -import gtk.Main; -import gtk.Window; - -import x11.X: Atom, ClientMessage, StructureNotifyMask, XWindow=Window; -import x11.Xlib: Display, XClientMessageEvent, XSendEvent, XEvent; +import x11.X : Atom, ClientMessage, StructureNotifyMask, XWindow = Window; +import x11.Xlib : Display, XClientMessageEvent, XSendEvent, XEvent; /** * This function activates an X11 using the _NET_ACTIVE_WINDOW @@ -47,14 +47,25 @@ import x11.Xlib: Display, XClientMessageEvent, XSendEvent, XEvent; * since code translations are considered a derived work under GPL. */ void activateX11Window(Window window) { - uint timestamp = Main.getCurrentEventTime(); + if (!x11FunctionsLoaded) { + warning("X11 functions not available, cannot activate window"); + return; + } + + uint timestamp = getCurrentEventTime(); + + GdkWindow gdkWin = window.getWindow(); + if (gdkWin is null) { + warning("GdkWindow is null, cannot activate X11 window"); + return; + } if (timestamp == 0) - timestamp = gdk_x11_get_server_time(window.getWindow().getWindowStruct()); + timestamp = gdk_x11_get_server_time(cast(GdkWindow_*) gdkWin._cPtr(No.Dup)); XClientMessageEvent event; event.type = ClientMessage; - event.window = getXid(window.getWindow()); + event.window = getXid(gdkWin); const(char*) name = toStringz("_NET_ACTIVE_WINDOW"); event.message_type = gdk_x11_get_xatom_by_name(name); event.format = 32; @@ -65,36 +76,88 @@ void activateX11Window(Window window) { Display* display = gdk_x11_get_default_xdisplay(); XWindow root = gdk_x11_get_default_root_xwindow(); - Gdk.errorTrapPush(); + errorTrapPush(); XSendEvent(display, root, false, StructureNotifyMask, cast(XEvent*) &event); - Gdk.flush; - if (Gdk.errorTrapPop() != 0) { + flush(); + if (errorTrapPop() != 0) { error("Failed to focus window"); } } -private: - -import gdk.c.functions; +/** + * Get the X11 window ID from a GdkWindow + */ +XWindow getXid(GdkWindow gdkWin) { + if (!x11FunctionsLoaded || gdkWin is null) { + return 0; + } + return gdk_x11_window_get_xid(cast(GdkWindow_*) gdkWin._cPtr(No.Dup)); +} -shared static this() -{ - // Link in some extra functions not provided by GtkD - Linker.link(gdk_x11_get_xatom_by_name, "gdk_x11_get_xatom_by_name", LIBRARY_GDK); - Linker.link(gdk_x11_get_default_xdisplay, "gdk_x11_get_default_xdisplay", LIBRARY_GDK); - Linker.link(gdk_x11_get_default_root_xwindow, "gdk_x11_get_default_root_xwindow", LIBRARY_GDK); - Linker.link(gdk_x11_get_server_time, "gdk_x11_get_server_time", LIBRARY_GDK); +/** + * Get the GType for X11 windows + */ +import gobject.c.types : GType; +GType getX11WindowType() { + if (!x11FunctionsLoaded) { + return 0; + } + return gdk_x11_window_get_type(); } -__gshared extern(C) -{ - Atom function(const(char)* atom_name) c_gdk_x11_get_xatom_by_name; - Display* function() c_gdk_x11_get_default_xdisplay; - XWindow function() c_gdk_x11_get_default_root_xwindow; - uint function(GdkWindow* window) c_gdk_x11_get_server_time; +private: + +// Flag to check if X11 functions are loaded +bool x11FunctionsLoaded = false; + +// Function pointer types for X11-specific GDK functions +extern (C) { + alias gdk_x11_get_xatom_by_name_func = Atom function(const(char)* atom_name); + alias gdk_x11_get_default_xdisplay_func = Display* function(); + alias gdk_x11_get_default_root_xwindow_func = XWindow function(); + alias gdk_x11_get_server_time_func = uint function(GdkWindow_* window); + alias gdk_x11_window_get_xid_func = XWindow function(GdkWindow_* window); + alias gdk_x11_window_get_type_func = GType function(); } -alias c_gdk_x11_get_xatom_by_name gdk_x11_get_xatom_by_name; -alias c_gdk_x11_get_default_xdisplay gdk_x11_get_default_xdisplay; -alias c_gdk_x11_get_default_root_xwindow gdk_x11_get_default_root_xwindow; -alias c_gdk_x11_get_server_time gdk_x11_get_server_time; +// Function pointers +__gshared gdk_x11_get_xatom_by_name_func gdk_x11_get_xatom_by_name; +__gshared gdk_x11_get_default_xdisplay_func gdk_x11_get_default_xdisplay; +__gshared gdk_x11_get_default_root_xwindow_func gdk_x11_get_default_root_xwindow; +__gshared gdk_x11_get_server_time_func gdk_x11_get_server_time; +__gshared gdk_x11_window_get_xid_func gdk_x11_window_get_xid; +__gshared gdk_x11_window_get_type_func gdk_x11_window_get_type; + +shared static this() { + // Try to load X11-specific GDK functions dynamically + void* handle = dlopen("libgdk-3.so.0", RTLD_NOW | RTLD_GLOBAL); + if (handle is null) { + handle = dlopen("libgdk-3.so", RTLD_NOW | RTLD_GLOBAL); + } + + if (handle is null) { + trace("Could not load libgdk-3.so for X11 functions"); + return; + } + + gdk_x11_get_xatom_by_name = cast(gdk_x11_get_xatom_by_name_func) dlsym(handle, "gdk_x11_get_xatom_by_name"); + gdk_x11_get_default_xdisplay = cast(gdk_x11_get_default_xdisplay_func) dlsym(handle, "gdk_x11_get_default_xdisplay"); + gdk_x11_get_default_root_xwindow = cast(gdk_x11_get_default_root_xwindow_func) dlsym(handle, "gdk_x11_get_default_root_xwindow"); + gdk_x11_get_server_time = cast(gdk_x11_get_server_time_func) dlsym(handle, "gdk_x11_get_server_time"); + gdk_x11_window_get_xid = cast(gdk_x11_window_get_xid_func) dlsym(handle, "gdk_x11_window_get_xid"); + gdk_x11_window_get_type = cast(gdk_x11_window_get_type_func) dlsym(handle, "gdk_x11_window_get_type"); + + // Check if all functions were loaded + x11FunctionsLoaded = (gdk_x11_get_xatom_by_name !is null && + gdk_x11_get_default_xdisplay !is null && + gdk_x11_get_default_root_xwindow !is null && + gdk_x11_get_server_time !is null && + gdk_x11_window_get_xid !is null && + gdk_x11_window_get_type !is null); + + if (x11FunctionsLoaded) { + trace("X11 GDK functions loaded successfully"); + } else { + trace("Some X11 GDK functions could not be loaded"); + } +} \ No newline at end of file diff --git a/source/gx/i18n/l10n.d b/source/gx/i18n/l10n.d index d70e64bce..166705573 100644 --- a/source/gx/i18n/l10n.d +++ b/source/gx/i18n/l10n.d @@ -4,7 +4,7 @@ */ module gx.i18n.l10n; -import glib.Internationalization; +import glib.global : dgettext, dpgettext2; void textdomain(string domain) { _textdomain = domain; @@ -15,7 +15,7 @@ void textdomain(string domain) { * and po files for translation */ string _(string text) { - return Internationalization.dgettext(_textdomain, text); + return dgettext(_textdomain, text); } /** @@ -24,7 +24,7 @@ string _(string text) { * translations, depending on the context in which they are used. */ string C_(string context, string text) { - return Internationalization.dpgettext2(_textdomain, context, text); + return dpgettext2(_textdomain, context, text); } /** @@ -37,4 +37,4 @@ string N_(string text) { } private: -string _textdomain; +string _textdomain; \ No newline at end of file diff --git a/source/gx/tilix/application.d b/source/gx/tilix/application.d index 653ddd0c7..89c77f77f 100644 --- a/source/gx/tilix/application.d +++ b/source/gx/tilix/application.d @@ -14,49 +14,57 @@ import std.process; import std.stdio; import std.variant; -import cairo.ImageSurface; - -import gdk.Screen; - -import gdkpixbuf.Pixbuf; - -import gio.ActionGroupIF; -import gio.ActionMapIF; -import gio.Application : GApplication = Application; -import gio.ApplicationCommandLine; -import gio.Menu; -import gio.MenuModel; -import gio.Settings : GSettings = Settings; -import gio.SimpleAction; - -import glib.GException; -import glib.ListG; -import glib.Str; -import glib.Variant : GVariant = Variant; -import glib.VariantDict : GVariantDict = VariantDict; -import glib.VariantType : GVariantType = VariantType; - -import gobject.ObjectG; -import gobject.ParamSpec; -import gobject.Value; - -import gtkc.gtk; - -import gtk.AboutDialog; -import gtk.Application; -import gtk.CheckButton; -import gtk.CssProvider; -import gtk.Dialog; -import gtk.Image; -import gtk.Label; -import gtk.LinkButton; -import gtk.Main; -import gtk.MessageDialog; -import gtk.Settings; -import gtk.StyleContext; -import gtk.Version; -import gtk.Widget; -import gtk.Window; +// GID imports - cairo +import cairo.surface : Surface; + +// GID imports - gdk +import gdk.screen : Screen; + +// GID imports - gdkpixbuf +import gdkpixbuf.pixbuf : Pixbuf; + +// GID imports - gio +import gio.action_group : ActionGroup; +import gio.action_map : ActionMap; +import gio.application : GioApplication = Application; +import gio.application_command_line : ApplicationCommandLine; +import gio.menu : Menu; +import gio.menu_model : MenuModel; +import gio.settings : GSettings = Settings; +import gio.simple_action : SimpleAction; +import gio.types : ApplicationFlags; + +// GID imports - glib +import glib.error : ErrorWrap; +import glib.variant : GVariant = Variant; +import glib.variant_type : GVariantType = VariantType; + +// GID imports - gobject +import gobject.object : ObjectWrap = ObjectWrap; +import gobject.param_spec : ParamSpec; +import gobject.value : Value; + +// GID imports - gtk +import gtk.about_dialog : AboutDialog; +import gtk.application : Application; +import gtk.c.functions : gtk_application_set_accels_for_action; +import gtk.c.types : GtkApplication, GOptionFlags, GOptionArg; +import gtk.check_button : CheckButton; +import gtk.css_provider : CssProvider; +import gtk.dialog : Dialog; +import gtk.global : checkVersion, getMajorVersion, getMinorVersion, getMicroVersion; +import gtk.image : Image; +import gtk.label : Label; +import gtk.link_button : LinkButton; +import gtk.message_dialog : MessageDialog; +import gtk.settings : GtkSettings = Settings; +import gtk.style_context : StyleContext; +import gtk.types : DialogFlags, MessageType, ButtonsType, ResponseType, IconSize; +import gtk.widget : Widget; +import gtk.window : Window; + +import gid.gid : No, Yes; +import std.string : toStringz; import gx.gtk.actions; import gx.gtk.cairo; @@ -116,7 +124,7 @@ private: PreferenceDialog preferenceDialog; //Background Image for terminals, store it here as singleton instance - ImageSurface isFullBGImage; + Surface isFullBGImage; bool warnedVTEConfigIssue = false; @@ -130,8 +138,17 @@ private: * Load and register binary resource file and add css files as providers */ void loadResources() { + import gtk.icon_theme : IconTheme; + //Load resources if (findResource(APPLICATION_RESOURCES, true)) { + // Register the gresource icon path with the icon theme + IconTheme iconTheme = IconTheme.getDefault(); + if (iconTheme !is null) { + iconTheme.addResourcePath(APPLICATION_RESOURCE_ROOT ~ "/icons"); + trace("Added icon resource path: " ~ APPLICATION_RESOURCE_ROOT ~ "/icons"); + } + foreach (cssFile; APPLICATION_CSS_RESOURCES) { string cssURI = APPLICATION_RESOURCE_ROOT ~ "/" ~ cssFile; if (!addCssProvider(cssURI, ProviderPriority.APPLICATION)) { @@ -160,7 +177,7 @@ private: } /** - * Registers the primary menu actions. + * Registers the primary menu actions. * * This code adapted from grestful (https://github.com/Gert-dev/grestful) */ @@ -170,8 +187,7 @@ private: * along with the sessionUUID */ registerAction(this, ACTION_PREFIX_APP, ACTION_ACTIVATE_SESSION, null, delegate(GVariant value, SimpleAction) { - size_t l; - string sessionUUID = value.getString(l); + string sessionUUID = value.getString(); tracef("activate-session triggered for session %s", sessionUUID); foreach (window; appWindows) { if (window.activateSession(sessionUUID)) { @@ -186,8 +202,7 @@ private: * along with the terminalUUID */ registerAction(this, ACTION_PREFIX_APP, ACTION_ACTIVATE_TERMINAL, null, delegate(GVariant value, SimpleAction) { - size_t l; - string terminalUUID = value.getString(l); + string terminalUUID = value.getString(); tracef("activate-terminal triggered for terminal %s", terminalUUID); foreach (window; appWindows) { if (window.activateTerminal(terminalUUID)) { @@ -203,9 +218,9 @@ private: registerActionWithSettings(this, ACTION_PREFIX_APP, ACTION_PREFERENCES, gsShortcuts, delegate(GVariant, SimpleAction) { onShowPreferences(); }); - if (Version.checkVersion(3, 19, 0).length == 0) { + if (checkVersion(3, 19, 0) is null) { registerActionWithSettings(this, ACTION_PREFIX_APP, ACTION_SHORTCUTS, gsShortcuts, delegate(GVariant, SimpleAction) { - import gtk.ShortcutsWindow: ShortcutsWindow; + import gtk.shortcuts_window: ShortcutsWindow; ShortcutsWindow window = getShortcutWindow(); if (window is null) return; @@ -255,7 +270,8 @@ private: void onShowAboutDialog() { AboutDialog dialog; - with (dialog = new AboutDialog()) { + dialog = new AboutDialog(); + with (dialog) { setTransientFor(getActiveWindow()); setDestroyWithParent(true); setModal(true); @@ -281,11 +297,11 @@ private: } addCreditSection(_("Credits"), localizedCredits); - addOnResponse(delegate(int responseId, Dialog sender) { - if (responseId == ResponseType.CANCEL || responseId == ResponseType.DELETE_EVENT) + connectResponse(delegate(int responseId, Dialog sender) { + if (responseId == ResponseType.Cancel || responseId == ResponseType.DeleteEvent) sender.hideOnDelete(); // Needed to make the window closable (and hide instead of be deleted). }); - addOnClose(delegate(Dialog dlg) { + connectClose(delegate(Dialog dlg) { dlg.destroy(); }); present(); @@ -341,19 +357,19 @@ private: Pixbuf.getFileInfo(filename, width, height); if (width > MAX_BG_WIDTH || height > MAX_BG_HEIGHT) { trace("Background image is too large, scaling"); - image = new Pixbuf(filename, MAX_BG_WIDTH, MAX_BG_HEIGHT, true); + image = Pixbuf.newFromFileAtScale(filename, MAX_BG_WIDTH, MAX_BG_HEIGHT, true); } else { - image = new Pixbuf(filename); + image = Pixbuf.newFromFile(filename); } isFullBGImage = renderImage(image, true); image.destroy(); } - } catch (GException ge) { + } catch (Exception e) { errorf("Could not load image '%s'", filename); } } - int onCommandLine(Scoped!ApplicationCommandLine acl, GApplication) { + int onCommandLine(ApplicationCommandLine acl, GioApplication) { trace("App processing command line"); scope (exit) { cp.clear(); @@ -457,7 +473,7 @@ private: return cp.exitCode; } - void onAppActivate(GApplication app) { + void onAppActivate(GioApplication app) { trace("Activate App Signal"); if (!app.getIsRemote()) { if (cp.preferences) presentPreferences(); @@ -466,7 +482,7 @@ private: cp.clear(); } - void handleThemeChange(ParamSpec, ObjectG) { + void handleThemeChange(ParamSpec, ObjectWrap) { string theme = getGtkTheme(); trace("Theme changed to " ~ theme); if (themeCssProvider !is null) { @@ -482,18 +498,18 @@ private: onThemeChange.emit(); } - void onAppStartup(GApplication) { + void onAppStartup(GioApplication) { trace("Startup App Signal"); - Settings.getDefault.addOnNotify(&handleThemeChange, "gtk-theme-name", ConnectFlags.AFTER); + GtkSettings.getDefault.connectNotify("gtk-theme-name", &handleThemeChange, No.After); loadResources(); gsDesktop = new GSettings(SETTINGS_DESKTOP_ID); - gsDesktop.addOnChanged(delegate(string key, Settings) { + gsDesktop.connectChanged(null, delegate(string key) { if (key == SETTINGS_COLOR_SCHEME_KEY) { applyPreference(SETTINGS_THEME_VARIANT_KEY); } }); gsShortcuts = new GSettings(SETTINGS_KEY_BINDINGS_ID); - gsShortcuts.addOnChanged(delegate(string key, Settings) { + gsShortcuts.connectChanged(null, delegate(string key) { string actionName = keyToDetailedActionName(key); //trace("Updating shortcut '" ~ actionName ~ "' to '" ~ gsShortcuts.getString(key) ~ "'"); setShortcut(actionName, gsShortcuts.getString(key)); @@ -502,7 +518,7 @@ private: // Set this once globally because it affects more then current window (i.e. shortcuts) useTabs = gsGeneral.getBoolean(SETTINGS_USE_TABS_KEY); _processMonitor = gsGeneral.getBoolean(SETTINGS_PROCESS_MONITOR); - gsGeneral.addOnChanged(delegate(string key, Settings) { + gsGeneral.connectChanged(null, delegate(string key) { applyPreference(key); }); @@ -518,7 +534,7 @@ private: if (shortcut == SHORTCUT_DISABLED) { char** tmp = (new char*[1]).ptr; tmp[0] = cast(char*) '\0'; - gtk_application_set_accels_for_action(gtkApplication, Str.toStringz(actionName), tmp); + gtk_application_set_accels_for_action(cast(GtkApplication*)_cPtr(No.Dup), toStringz(actionName), tmp); trace("Removing accelerator"); } else { setAccelsForAction(actionName, [shortcut]); @@ -544,7 +560,7 @@ private: } } - void onAppShutdown(GApplication) { + void onAppShutdown(GioApplication) { trace("Quit App Signal"); if (bmMgr.hasChanged()) { bmMgr.save(); @@ -579,31 +595,30 @@ private: /* * Resetting the theme variant to "Default" depends on new * gtk_settings_reset_property API in Gnome 3.20. Once - * GtkD is updated to include this it will be added here. + * the binding is updated to include this it will be added here. */ - if (Version.checkVersion(3, 19, 0).length == 0) { - Settings.getDefault.resetProperty(GTK_APP_PREFER_DARK_THEME); + if (checkVersion(3, 19, 0) is null) { + GtkSettings.getDefault.resetProperty(GTK_APP_PREFER_DARK_THEME); } } else { - Settings.getDefault().setProperty(GTK_APP_PREFER_DARK_THEME, darkMode); + GtkSettings.getDefault().gtkApplicationPreferDarkTheme = darkMode; } onThemeChange.emit(); clearBookmarkIconCache(); break; case SETTINGS_MENU_ACCELERATOR_KEY: if (defaultMenuAccel is null) { - defaultMenuAccel = new Value("F10"); - Settings.getDefault().getProperty(GTK_MENU_BAR_ACCEL, defaultMenuAccel); + defaultMenuAccel = new Value(GtkSettings.getDefault().gtkMenuBarAccel); trace("Default menu accelerator is " ~ defaultMenuAccel.getString()); } if (!gsGeneral.getBoolean(SETTINGS_MENU_ACCELERATOR_KEY)) { - Settings.getDefault().setProperty(GTK_MENU_BAR_ACCEL, new Value("")); + GtkSettings.getDefault().gtkMenuBarAccel = ""; } else { - Settings.getDefault().setProperty(GTK_MENU_BAR_ACCEL, defaultMenuAccel); + GtkSettings.getDefault().gtkMenuBarAccel = defaultMenuAccel.getString(); } break; case SETTINGS_ACCELERATORS_ENABLED: - Settings.getDefault().setProperty(GTK_ENABLE_ACCELS, gsGeneral.getBoolean(SETTINGS_ACCELERATORS_ENABLED)); + GtkSettings.getDefault().gtkEnableAccels = gsGeneral.getBoolean(SETTINGS_ACCELERATORS_ENABLED); break; case SETTINGS_BACKGROUND_IMAGE_KEY, SETTINGS_BACKGROUND_IMAGE_MODE_KEY, SETTINGS_BACKGROUND_IMAGE_SCALE_KEY: if (key == SETTINGS_BACKGROUND_IMAGE_KEY) { @@ -626,7 +641,7 @@ private: Widget widget = findWidgetForUUID(terminalUUID); Widget result = widget; while (widget !is null) { - ActionGroupIF group = widget.getActionGroup(prefix); + ActionGroup group = widget.getActionGroup(prefix); if (group !is null && group.hasAction(actionName)) { tracef("Activating action for prefix=%s and action=%s", prefix, actionName); group.activateAction(actionName, null); @@ -651,9 +666,8 @@ private: AppWindow appWindow = cast(AppWindow)getActiveWindow(); if (appWindow !is null) return appWindow; - ListG list = getWindows(); - if (list is null) return null; - Window[] windows = list.toArray!(Window)(); + Window[] windows = getWindows(); + if (windows is null) return null; foreach(window; windows) { appWindow = cast(AppWindow) window; if (appWindow !is null) return appWindow; @@ -662,9 +676,8 @@ private: } AppWindow getQuakeWindow() { - ListG list = getWindows(); - if (list is null) return null; - Window[] windows = list.toArray!(Window)(); + Window[] windows = getWindows(); + if (windows is null) return null; foreach(window; windows) { AppWindow appWindow = cast(AppWindow) window; if (appWindow !is null && appWindow.isQuake()) return appWindow; @@ -676,41 +689,44 @@ private: * Add main options supported by application */ void addOptions() { - addMainOption(CMD_WORKING_DIRECTORY, 'w', GOptionFlags.NONE, GOptionArg.STRING, _("Set the working directory of the terminal"), _("DIRECTORY")); - addMainOption(CMD_PROFILE, 'p', GOptionFlags.NONE, GOptionArg.STRING, _("Set the starting profile"), _("PROFILE_NAME")); - addMainOption(CMD_TITLE, 't', GOptionFlags.NONE, GOptionArg.STRING, _("Set the title of the new terminal"), _("TITLE")); - addMainOption(CMD_SESSION, 's', GOptionFlags.NONE, GOptionArg.STRING_ARRAY, _("Open the specified session"), _("SESSION_NAME")); - if (Version.checkVersion(3, 16, 0).length ==0) { - addMainOption(CMD_ACTION, 'a', GOptionFlags.NONE, GOptionArg.STRING, _("Send an action to current Tilix instance"), _("ACTION_NAME")); - } - addMainOption(CMD_COMMAND, 'e', GOptionFlags.NONE, GOptionArg.STRING, _("Execute the parameter as a command"), _("COMMAND")); - addMainOption(CMD_MAXIMIZE, '\0', GOptionFlags.NONE, GOptionArg.NONE, _("Maximize the terminal window"), null); - addMainOption(CMD_MINIMIZE, '\0', GOptionFlags.NONE, GOptionArg.NONE, _("Minimize the terminal window"), null); - addMainOption(CMD_WINDOW_STYLE, '\0', GOptionFlags.NONE, GOptionArg.STRING, _("Override the preferred window style to use, one of: normal,disable-csd,disable-csd-hide-toolbar,borderless"), _("WINDOW_STYLE")); - addMainOption(CMD_FULL_SCREEN, '\0', GOptionFlags.NONE, GOptionArg.NONE, _("Full-screen the terminal window"), null); - addMainOption(CMD_FOCUS_WINDOW, '\0', GOptionFlags.NONE, GOptionArg.NONE, _("Focus the existing window"), null); - addMainOption(CMD_NEW_PROCESS, '\0', GOptionFlags.NONE, GOptionArg.NONE, _("Start additional instance as new process (Not Recommended)"), null); - addMainOption(CMD_GEOMETRY, '\0', GOptionFlags.NONE, GOptionArg.STRING, _("Set the window size; for example: 80x24, or 80x24+200+200 (COLSxROWS+X+Y)"), _("GEOMETRY")); - addMainOption(CMD_QUAKE, 'q', GOptionFlags.NONE, GOptionArg.NONE, _("Opens a window in quake mode or toggles existing quake mode window visibility"), null); - addMainOption(CMD_VERSION, 'v', GOptionFlags.NONE, GOptionArg.NONE, _("Show the Tilix and dependent component versions"), null); - addMainOption(CMD_PREFERENCES, '\0', GOptionFlags.NONE, GOptionArg.NONE, _("Show the Tilix preferences dialog directly"), null); - addMainOption(CMD_GROUP, 'g', GOptionFlags.NONE, GOptionArg.STRING, _("Group tilix instances into different processes (Experimental, not recommended)"), _("GROUP_NAME")); + addMainOption(CMD_WORKING_DIRECTORY, 'w', GOptionFlags.None, GOptionArg.String, _("Set the working directory of the terminal"), _("DIRECTORY")); + addMainOption(CMD_PROFILE, 'p', GOptionFlags.None, GOptionArg.String, _("Set the starting profile"), _("PROFILE_NAME")); + addMainOption(CMD_TITLE, 't', GOptionFlags.None, GOptionArg.String, _("Set the title of the new terminal"), _("TITLE")); + addMainOption(CMD_SESSION, 's', GOptionFlags.None, GOptionArg.StringArray, _("Open the specified session"), _("SESSION_NAME")); + if (checkVersion(3, 16, 0) is null) { + addMainOption(CMD_ACTION, 'a', GOptionFlags.None, GOptionArg.String, _("Send an action to current Tilix instance"), _("ACTION_NAME")); + } + addMainOption(CMD_COMMAND, 'e', GOptionFlags.None, GOptionArg.String, _("Execute the parameter as a command"), _("COMMAND")); + addMainOption(CMD_MAXIMIZE, '\0', GOptionFlags.None, GOptionArg.None, _("Maximize the terminal window"), null); + addMainOption(CMD_MINIMIZE, '\0', GOptionFlags.None, GOptionArg.None, _("Minimize the terminal window"), null); + addMainOption(CMD_WINDOW_STYLE, '\0', GOptionFlags.None, GOptionArg.String, _("Override the preferred window style to use, one of: normal,disable-csd,disable-csd-hide-toolbar,borderless"), _("WINDOW_STYLE")); + addMainOption(CMD_FULL_SCREEN, '\0', GOptionFlags.None, GOptionArg.None, _("Full-screen the terminal window"), null); + addMainOption(CMD_FOCUS_WINDOW, '\0', GOptionFlags.None, GOptionArg.None, _("Focus the existing window"), null); + addMainOption(CMD_NEW_PROCESS, '\0', GOptionFlags.None, GOptionArg.None, _("Start additional instance as new process (Not Recommended)"), null); + addMainOption(CMD_GEOMETRY, '\0', GOptionFlags.None, GOptionArg.String, _("Set the window size; for example: 80x24, or 80x24+200+200 (COLSxROWS+X+Y)"), _("GEOMETRY")); + addMainOption(CMD_QUAKE, 'q', GOptionFlags.None, GOptionArg.None, _("Opens a window in quake mode or toggles existing quake mode window visibility"), null); + addMainOption(CMD_VERSION, 'v', GOptionFlags.None, GOptionArg.None, _("Show the Tilix and dependent component versions"), null); + addMainOption(CMD_PREFERENCES, '\0', GOptionFlags.None, GOptionArg.None, _("Show the Tilix preferences dialog directly"), null); + addMainOption(CMD_GROUP, 'g', GOptionFlags.None, GOptionArg.String, _("Group tilix instances into different processes (Experimental, not recommended)"), _("GROUP_NAME")); //Hidden options used to communicate with primary instance - addMainOption(CMD_TERMINAL_UUID, '\0', GOptionFlags.HIDDEN, GOptionArg.STRING, _("Hidden argument to pass terminal UUID"), _("TERMINAL_UUID")); + addMainOption(CMD_TERMINAL_UUID, '\0', GOptionFlags.Hidden, GOptionArg.String, _("Hidden argument to pass terminal UUID"), _("TERMINAL_UUID")); } public: + @property AppWindow[] getAppWindows() { + return appWindows; + } this(bool newProcess, string group=null) { - ApplicationFlags flags = ApplicationFlags.HANDLES_COMMAND_LINE; - if (newProcess) flags |= ApplicationFlags.NON_UNIQUE; - //flags |= ApplicationFlags.CAN_OVERRIDE_APP_ID; + ApplicationFlags flags = ApplicationFlags.HandlesCommandLine; + if (newProcess) flags |= ApplicationFlags.NonUnique; + //flags |= ApplicationFlags.CanOverrideAppId; super(APPLICATION_ID, flags); if (group.length > 0) { string id = "com.gexperts.Tilix." ~ group; - if (idIsValid(id)) { + if (GioApplication.idIsValid(id)) { tracef("Setting app id to %s", id); setApplicationId(id); } else { @@ -720,10 +736,10 @@ public: addOptions(); - this.addOnActivate(&onAppActivate); - this.addOnStartup(&onAppStartup); - this.addOnShutdown(&onAppShutdown); - this.addOnCommandLine(&onCommandLine); + this.connectActivate(&onAppActivate); + this.connectStartup(&onAppStartup); + this.connectShutdown(&onAppShutdown); + this.connectCommandLine(&onCommandLine); tilix = this; } @@ -737,7 +753,7 @@ public: */ void executeCommand(string command, string terminalID, string cmdLine) { GVariant[] param = [new GVariant(command), new GVariant(terminalID), new GVariant(cmdLine)]; - activateAction(ACTION_COMMAND, new GVariant(param)); + activateAction(ACTION_COMMAND, GVariant.newTuple(param)); } bool isQuake() { @@ -799,7 +815,7 @@ public: //Otherwise create it and save the ID trace("Creating preference window"); preferenceDialog = new PreferenceDialog(getActiveAppWindow()); - preferenceDialog.addOnDestroy(delegate(Widget) { + preferenceDialog.connectDestroy(delegate() { trace("Remove preference window reference"); preferenceDialog = null; }); @@ -857,7 +873,7 @@ public: return cp; } - ImageSurface getBackgroundImage() { + Surface getBackgroundImage() { return isFullBGImage; } @@ -878,26 +894,41 @@ public: * for more information. */ void warnVTEConfigIssue() { + import gtk.c.functions : gtk_message_dialog_new; + import gtk.c.types : GtkDialogFlags, GtkMessageType, GtkButtonsType, GtkWidget, GtkWindow; + import gtk.box : Box; + if (testVTEConfig()) { warnedVTEConfigIssue = true; string msg = _("There appears to be an issue with the configuration of the terminal.\nThis issue is not serious, but correcting it will improve your experience.\nClick the link below for more information:"); - string title = "" ~ _("Configuration Issue Detected") ~ ""; - MessageDialog dlg = new MessageDialog(getActiveWindow(), DialogFlags.MODAL, MessageType.WARNING, ButtonsType.OK, null, null); + string dlgTitle = "" ~ _("Configuration Issue Detected") ~ ""; + + GtkDialogFlags dflags = GtkDialogFlags.Modal; + GtkWidget* widget = gtk_message_dialog_new( + getActiveWindow() ? cast(GtkWindow*) getActiveWindow()._cPtr(No.Dup) : null, + dflags, + GtkMessageType.Warning, + GtkButtonsType.Ok, + null, + null + ); + MessageDialog dlg = ObjectWrap._getDObject!MessageDialog(cast(void*) widget, No.Take); scope (exit) { dlg.destroy(); } - with (dlg) { - setTransientFor(getActiveWindow()); - setMarkup(title); - getMessageArea().setMarginLeft(0); - getMessageArea().setMarginRight(0); - getMessageArea().add(new Label(msg)); - getMessageArea().add(new LinkButton("https://gnunn1.github.io/tilix-web/manual/vteconfig/")); - CheckButton cb = new CheckButton(_("Do not show this message again")); - getMessageArea().add(cb); - setImage(new Image("dialog-warning", IconSize.DIALOG)); - showAll(); - run(); + dlg.setTransientFor(getActiveWindow()); + dlg.setMarkup(dlgTitle); + Box msgArea = cast(Box) dlg.getMessageArea(); + if (msgArea !is null) { + msgArea.setMarginStart(0); + msgArea.setMarginEnd(0); + msgArea.add(new Label(msg)); + msgArea.add(new LinkButton("https://gnunn1.github.io/tilix-web/manual/vteconfig/")); + CheckButton cb = CheckButton.newWithLabel(_("Do not show this message again")); + msgArea.add(cb); + dlg.setImage(Image.newFromIconName("dialog-warning", IconSize.Dialog)); + dlg.showAll(); + dlg.run(); if (cb.getActive()) { gsGeneral.setBoolean(SETTINGS_WARN_VTE_CONFIG_ISSUE_KEY, false); } @@ -919,10 +950,10 @@ public: public: /** * Invoked when the GTK theme or theme-variant has changed. While - * things could listen to gtk.Settings.addOnNotify directly, - * because this is a long lived object and GtkD doesn't provide a + * things could listen to gtk.Settings.connectNotify directly, + * because this is a long lived object and the binding doesn't provide a * way to remove listeners it will lead to memory leaks so we use * this instead */ GenericEvent!() onThemeChange; -} +} \ No newline at end of file diff --git a/source/gx/tilix/appwindow.d b/source/gx/tilix/appwindow.d index ef5be8925..ceedac6c6 100644 --- a/source/gx/tilix/appwindow.d +++ b/source/gx/tilix/appwindow.d @@ -7,6 +7,7 @@ module gx.tilix.appwindow; import core.memory; import std.algorithm; +import std.array; import std.conv; import std.experimental.logger; import std.file; @@ -18,77 +19,99 @@ import std.process; import std.string; import std.uuid; -import cairo.Context; -import cairo.ImageSurface; - -import gtk.Application : Application; -import gio.Application : GioApplication = Application; -import gtk.ApplicationWindow : ApplicationWindow; -import gtkc.giotypes : GApplicationFlags; - -import gdkpixbuf.Pixbuf; - -import gdk.Event; -import gdk.Keysyms; -import gdk.RGBA; -import gdk.Screen; -import gdk.Visual; - -import gio.ActionIF; -import gio.ActionMapIF; -import gio.Menu : GMenu = Menu; -import gio.MenuItem : GMenuItem = MenuItem; -import gio.Notification; -import gio.Settings : GSettings = Settings; -import gio.SimpleAction; -import gio.SimpleActionGroup; - -import glib.GException; -import glib.ListG; -import glib.ListSG; -import glib.Util; -import glib.Variant : GVariant = Variant; -import glib.VariantType : GVariantType = VariantType; - -import gobject.Signals; -import gobject.Value; - -import gtk.AspectFrame; -import gtk.Box; -import gtk.Button; -import gtk.CheckButton; -import gtk.Dialog; -import gtk.Entry; -import gtk.EventBox; -import gtk.FileChooserDialog; -import gtk.FileFilter; -import gtk.Frame; -import gtk.Grid; -import gtk.HeaderBar; -import gtk.Image; -import gtk.Label; -import gtk.ListBox; -import gtk.ListBoxRow; -import gtk.MenuButton; -import gtk.MessageDialog; -import gtk.Notebook; -import gtk.Overlay; -import gtk.Popover; -import gtk.Revealer; -import gtk.ScrolledWindow; -import gtk.Settings; -import gtk.Stack; -import gtk.StyleContext; -import gtk.ToggleButton; -import gtk.Version; -import gtk.Widget; -import gtk.Window; -import gtk.WindowGroup; - -import gtkc.glib; - -import vte.Pty; -import vte.Terminal; +// GID imports - cairo +import cairo.context : Context; +import cairo.surface : Surface; +import cairo.types : Filter, FontSlant, FontWeight, TextExtents; + +// GID imports - gdk +import gdk.event : Event; +import gdk.event_button : EventButton; +import gdk.event_focus : EventFocus; +import gdk.event_key : EventKey; +import gdk.event_scroll : EventScroll; +import gdk.event_window_state : EventWindowState; +import gdk.rectangle : Rectangle; +import gdk.rgba : RGBA; +import gdk.screen : Screen; +import gdk.types : ScrollDirection, EventType, Gravity, WindowState, ModifierType; +import gdk.c.types : GdkRectangle; +import gdk.visual : Visual; + +// GID imports - gdkpixbuf +import gdkpixbuf.pixbuf : Pixbuf; + +// GID imports - gio +import gio.action : Action; +import gio.action_map : ActionMap; +import gio.application : GioApplication = Application; +import gio.menu : GMenu = Menu; +import gio.menu_item : GMenuItem = MenuItem; +import gio.notification : Notification; +import gio.settings : GSettings = Settings, Settings; +import gio.simple_action : SimpleAction; +import gio.simple_action_group : SimpleActionGroup; +import gio.types : ApplicationFlags; + +// GID imports - glib +import glib.error : ErrorWrap; +import glib.global : getHomeDir; +import glib.variant : GVariant = Variant, Variant; +import glib.variant_type : GVariantType = VariantType; + +// GID imports - gobject +import gobject.object : ObjectWrap = ObjectWrap; +import gobject.global : signalHandlerBlock, signalHandlerUnblock; +import gobject.value : Value; + +// GID imports - gtk +import gtk.application : Application; +import gtk.application_window : ApplicationWindow; +import gtk.aspect_frame : AspectFrame; +import gtk.box : Box; +import gtk.button : Button; +import gtk.check_button : CheckButton; +import gtk.dialog : Dialog; +import gtk.entry : Entry; +import gtk.event_box : EventBox; +import gtk.file_chooser_dialog : FileChooserDialog; +import gtk.file_filter : FileFilter; +import gtk.frame : Frame; +import gtk.global : checkVersion; +import gtk.grid : Grid; +import gtk.header_bar : HeaderBar; +import gtk.image : Image; +import gtk.label : Label; +import gtk.list_box : ListBox; +import gtk.list_box_row : ListBoxRow; +import gtk.menu_button : MenuButton; +import gtk.message_dialog : MessageDialog; +import gtk.notebook : Notebook; +import gtk.overlay : Overlay; +import gtk.popover : Popover; +import gtk.revealer : Revealer; +import gtk.scrolled_window : ScrolledWindow; +import gtk.settings : GtkSettings = Settings; +import gtk.stack : Stack; +import gtk.style_context : StyleContext; +import gtk.toggle_button : ToggleButton; +import gtk.types : Allocation, IconSize, Orientation, PositionType, ShadowType, ReliefStyle, ResponseType, DialogFlags, MessageType, ButtonsType, FileChooserAction; +import pango.types : EllipsizeMode; +import gtk.widget : Widget; +import gtk.window : Window; +import gtk.window_group : WindowGroup; + +// GID imports - vte +import vte.pty : Pty; +import vte.terminal : Terminal; + +import gid.gid : No, Yes; + +// GDK key constants (not provided by GID) +enum GdkKeysyms { + GDK_Escape = 0xff1b, + GDK_Return = 0xff0d, +} import gx.gtk.actions; import gx.gtk.cairo; @@ -177,7 +200,7 @@ private: GSettings gsSettings; // Cached rendered background image - ImageSurface isBGImage; + Surface isBGImage; // Track size changes, only invalidate if size really changed int lastWidth, lastHeight; @@ -196,7 +219,7 @@ private: bool _noPrompt = false; // Handler of the Find button "toggled" signal - gulong _tbFindToggledId; + ulong _tbFindToggledId; // Preference for the Window Style, i.e normal,disable-csd,disable-csd-hide-toolbar,borderless size_t windowStyle = 0; @@ -220,83 +243,58 @@ private: } /** - * Create the user interface + * Create the Tilix user interface */ void createUI() { + // Setup notebook for session tabs + nb = new Notebook(); + nb.setShowBorder(false); + nb.setScrollable(true); + nb.setShowTabs(useTabs); + nb.setGroupName(APPLICATION_NAME); + nb.connectPageAdded(&onPageAdded); + nb.connectPageRemoved(&onPageRemoved); + nb.connectSwitchPage(delegate void(Widget page, uint index) { + Session session = cast(Session) page; + if (session !is null) { + onSessionSelected(session.uuid); + } + }); + nb.connectCreateWindow(&onCreateWindow); + GSettings gsShortcuts = new GSettings(SETTINGS_KEY_BINDINGS_ID); createWindowActions(gsShortcuts); createSessionActions(gsShortcuts); createDelegatedTerminalActions(gsShortcuts); + insertActionGroup(ACTION_PREFIX, sessionActions); - //Notebook - nb = new Notebook(); - nb.setShowTabs(false); - nb.setShowBorder(false); - if (useTabs) { - nb.getStyleContext().addClass("tilix-background"); - nb.setScrollable(true); - nb.setGroupName("tilix"); - nb.addOnCreateWindow(&onCreateWindow); - nb.setCanFocus(false); - } - nb.addOnPageAdded(&onPageAdded); - nb.addOnPageRemoved(&onPageRemoved); - nb.addOnSwitchPage(delegate(Widget page, uint, Notebook) { - trace("Switched Sessions"); - Session session = cast(Session) page; - //Remove any sessions associated with current page - sessionNotifications.remove(session.uuid); - updateTitle(); - updateUIState(); - session.notifyActive(); - session.focusRestore(); - saSyncInput.setState(new GVariant(session.synchronizeInput)); - if (!useTabs && sb.getChildRevealed() && getCurrentSession() !is null) { - sb.selectSession(getCurrentSession().uuid); - } - if (useTabs) { - threadsAddIdleDelegate(delegate() { - // Delay focus restore - trace("Delayed focus restore"); - session.focusRestore(); - SessionTabLabel label = cast(SessionTabLabel) nb.getTabLabel(session); - label.showNewOutput(false); - return false; - }); - } - tilix.withdrawNotification(session.uuid); - }, ConnectFlags.AFTER); + hb = createHeaderBar(); + applyPreference(SETTINGS_TAB_POSITION_KEY); + + Overlay overlay; if (!useTabs) { + // Create sidebar sb = new SideBar(); - sb.onSelected.connect(&onSessionSelected); - sb.onClose.connect(&onUserSessionClose); - sb.onRequestReorder.connect(&onSessionReorder); + sb.onSelected.connect(&onOpenSelected); + sb.onFileSelected.connect(&onFileSelected); + sb.onFileRemoved.connect(&onFileRemoved); + sb.onOpenSelected.connect(&onOpenSelected); + sb.onSessionAttach.connect(&onSessionAttach); + sb.onSessionReorder.connect(&onSessionReorder); sb.onSessionDetach.connect(&onSessionDetach); - sb.onIsActionAllowed.connect(&onIsActionAllowed); - } else { - updateTabPosition(); - } - Overlay overlay; - if (!useTabs) { + // Create overlay overlay = new Overlay(); overlay.add(nb); overlay.addOverlay(sb); } - //Could be a Box or a Headerbar depending on value of disable_csd - hb = createHeaderBar(); - - if (isQuake() || isCSDDisabled()) { - hb.getStyleContext().addClass("tilix-embedded-headerbar"); - Box box = new Box(Orientation.VERTICAL, 0); - box.add(hb); - if (overlay !is null) box.add(overlay); - else box.add(nb); - if (isQuake()) { - box.getStyleContext().addClass("tilix-quake-frame"); - } + if (isCSDDisabled()) { + Box box = new Box(Orientation.Vertical, 0); + box.packStart(hb, false, true, 0); + if (overlay !is null) box.packStart(overlay, true, true, 0); + else box.packStart(nb, true, true, 0); add(box); hb.setNoShowAll(hideToolbar()); } else { @@ -312,13 +310,13 @@ private: //New tab button Button btnNew; if (useTabs) { - btnNew = new Button("tab-new-symbolic", IconSize.BUTTON); + btnNew = Button.newFromIconName("tab-new-symbolic", IconSize.Button); } else { - btnNew = new Button("list-add-symbolic", IconSize.BUTTON); + btnNew = Button.newFromIconName("list-add-symbolic", IconSize.Button); } btnNew.setFocusOnClick(false); btnNew.setAlwaysShowImage(true); - btnNew.addOnClicked(delegate(Button) { + btnNew.connectClicked(delegate() { createSession(); }); btnNew.setTooltipText(_("Create a new session")); @@ -329,31 +327,28 @@ private: //View sessions button tbSideBar = new ToggleButton(); tbSideBar.getStyleContext().addClass("session-sidebar-button"); - Box b = new Box(Orientation.HORIZONTAL, 6); + Box b = new Box(Orientation.Horizontal, 6); lblSideBar = new Label("1 / 1"); - Image img = new Image("pan-down-symbolic", IconSize.MENU); + Image img = Image.newFromIconName("pan-down-symbolic", IconSize.Menu); b.add(lblSideBar); b.add(img); tbSideBar.add(b); tbSideBar.setTooltipText(_("View session sidebar")); tbSideBar.setFocusOnClick(false); tbSideBar.setActionName(getActionDetailedName("win", ACTION_WIN_SIDEBAR)); - tbSideBar.addOnDraw(&drawSideBarBadge, ConnectFlags.AFTER); - tbSideBar.addOnScroll(delegate(Event event, Widget w) { - ScrollDirection direction; - event.getScrollDirection(direction); - - if (direction == ScrollDirection.UP) { + tbSideBar.connectDraw(&drawSideBarBadge, Yes.After); + tbSideBar.connectScrollEvent(delegate bool(EventScroll event) { + ScrollDirection direction = event.direction; + if (direction == ScrollDirection.Up) { focusPreviousSession(); - } else if (direction == ScrollDirection.DOWN) { + } else if (direction == ScrollDirection.Down) { focusNextSession(); } - return false; }); - tbSideBar.addEvents(EventType.SCROLL); + tbSideBar.addEvents(EventType.Scroll); - bSessionButtons = new Box(Orientation.HORIZONTAL, 0); + bSessionButtons = new Box(Orientation.Horizontal, 0); bSessionButtons.getStyleContext().addClass("linked"); btnNew.getStyleContext().addClass("session-new-button"); bSessionButtons.packStart(tbSideBar, false, false, 0); @@ -363,26 +358,26 @@ private: //Session Actions mbSessionActions = new MenuButton(); mbSessionActions.setFocusOnClick(false); - Image iHamburger = new Image("open-menu-symbolic", IconSize.MENU); + Image iHamburger = Image.newFromIconName("open-menu-symbolic", IconSize.Menu); mbSessionActions.add(iHamburger); mbSessionActions.setPopover(createPopover(mbSessionActions)); - Button btnAddHorizontal = new Button("tilix-add-horizontal-symbolic", IconSize.MENU); + Button btnAddHorizontal = Button.newFromIconName("tilix-add-horizontal-symbolic", IconSize.Menu); btnAddHorizontal.setDetailedActionName(getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_ADD_RIGHT)); btnAddHorizontal.setFocusOnClick(false); btnAddHorizontal.setTooltipText(_("Add terminal right")); - Button btnAddVertical = new Button("tilix-add-vertical-symbolic", IconSize.MENU); + Button btnAddVertical = Button.newFromIconName("tilix-add-vertical-symbolic", IconSize.Menu); btnAddVertical.setDetailedActionName(getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_ADD_DOWN)); btnAddVertical.setTooltipText(_("Add terminal down")); btnAddVertical.setFocusOnClick(false); // Add find button tbFind = new ToggleButton(); - tbFind.setImage(new Image("edit-find-symbolic", IconSize.MENU)); + tbFind.setImage(Image.newFromIconName("edit-find-symbolic", IconSize.Menu)); tbFind.setTooltipText(_("Find text in terminal")); tbFind.setFocusOnClick(false); - _tbFindToggledId = tbFind.addOnToggled(delegate(ToggleButton) { + _tbFindToggledId = tbFind.connectToggled(delegate() { if (getCurrentSession() !is null) { getCurrentSession().toggleTerminalFind(); } @@ -406,8 +401,8 @@ private: } void onCustomTitleChange(string title) { - _overrideTitle = title; - updateTitle; + _overrideTitle = title; + updateTitle(); } void onCustomTitleCancelEdit() { @@ -419,8 +414,8 @@ private: void onCustomTitleEdit(CumulativeResult!string result) { if (_overrideTitle.length > 0) { result.addResult(_overrideTitle); - } else { - result.addResult(gsSettings.getString(SETTINGS_APP_TITLE_KEY)); + } else if (getCurrentSession() !is null) { + result.addResult(getCurrentSession().displayName()); } } @@ -433,377 +428,283 @@ private: } /** - * Create Window actions + * Create the window actions */ void createWindowActions(GSettings gsShortcuts) { - debug(GC) { - registerAction(this, "win", "gc", null, delegate(GVariant, SimpleAction) { - trace("Performing collection"); - core.memory.GC.collect(); - core.memory.GC.minimize(); - }); - } - - //Create Switch to Session (0..9) actions - //Can't use :: action targets for this since action name needs to be preferences - for (int i = 0; i <= 9; i++) { - registerActionWithSettings(this, "win", ACTION_WIN_SESSION_X ~ to!string(i), gsShortcuts, delegate(GVariant, SimpleAction sa) { - int index = to!int(sa.getName()[$ - 1 .. $]); - if (index == 0) - index = 9; - else - index--; - if (index <= nb.getNPages()) { - nb.setCurrentPage(index); - } - }); - } + saViewSideBar = registerActionWithSettings(this, "win", ACTION_WIN_SIDEBAR, gsShortcuts, delegate(Variant value, SimpleAction sa) { + bool newState = !sa.getState().getBoolean(); + sa.setState(new GVariant(newState)); + if (sb !is null) { + sb.reveal(newState); + } + }, null, new GVariant(!useTabs)); // Initial state: false if using tabs - registerActionWithSettings(this, "win", ACTION_WIN_NEXT_SESSION, gsShortcuts, delegate(GVariant, SimpleAction) { - focusNextSession(); - }); - registerActionWithSettings(this, "win", ACTION_WIN_PREVIOUS_SESSION, gsShortcuts, delegate(GVariant, SimpleAction) { - focusPreviousSession(); + registerActionWithSettings(this, "win", ACTION_WIN_SESSIONSWITCHER, gsShortcuts, delegate(Variant, SimpleAction) { + if (sb !is null) { + sb.showSessionSwitcher(); + } }); - registerActionWithSettings(this, "win", ACTION_SESSION_REORDER_PREVIOUS, gsShortcuts, delegate(GVariant, SimpleAction) { - reorderCurrentSessionRelative(-1); + registerActionWithSettings(this, "win", ACTION_WIN_NEXT_SESSION, gsShortcuts, delegate(Variant, SimpleAction) { + focusNextSession(); }); - registerActionWithSettings(this, "win", ACTION_SESSION_REORDER_NEXT, gsShortcuts, delegate(GVariant, SimpleAction) { - reorderCurrentSessionRelative(1); + registerActionWithSettings(this, "win", ACTION_WIN_PREVIOUS_SESSION, gsShortcuts, delegate(Variant, SimpleAction) { + focusPreviousSession(); }); - registerActionWithSettings(this, "win", ACTION_WIN_FULLSCREEN, gsShortcuts, delegate(GVariant value, SimpleAction sa) { - trace("Setting fullscreen"); - if (getWindow() !is null && ((getWindow().getState() & GdkWindowState.FULLSCREEN) == GdkWindowState.FULLSCREEN)) { - unfullscreen(); - sa.setState(new GVariant(false)); - } else { + registerActionWithSettings(this, "win", ACTION_WIN_FULLSCREEN, gsShortcuts, delegate(Variant value, SimpleAction sa) { + bool newState = !sa.getState().getBoolean(); + sa.setState(new GVariant(newState)); + if (newState) { fullscreen(); - sa.setState(new GVariant(true)); + } else { + unfullscreen(); } - }, null, new GVariant(false)); - - if (!useTabs) { - saViewSideBar = registerActionWithSettings(this, "win", ACTION_WIN_SIDEBAR, gsShortcuts, delegate(GVariant value, SimpleAction sa) { - bool newState = !sa.getState().getBoolean(); - trace("Sidebar action activated " ~ to!string(newState)); - // Note that populate sessions does some weird shit with event - // handling, don't trigger UI activity until after it is done - // See comments in gx.gtk.cairo.getWidgetImage - if (newState) { - sb.populateSessions(getSessions(), getCurrentSession().uuid, sessionNotifications, nb.getAllocatedWidth(), nb.getAllocatedHeight()); - sb.showAll(); - } - sb.setRevealChild(newState); - sa.setState(new GVariant(newState)); - tbSideBar.setActive(newState); - if (!newState) { - //Hiding session, restore focus - Session session = getCurrentSession(); - if (session !is null) { - session.focusRestore(); - } - } - }, null, new GVariant(false)); + }, null, new GVariant(false)); // Initial state: not fullscreen + + // Register actions for switching to session (1-10) + for (int i = 1; i <= 10; i++) { + immutable int num = i; + string actionName = ACTION_WIN_SESSION_X ~ to!string(i); + registerActionWithSettings(this, "win", actionName, gsShortcuts, delegate(Variant, SimpleAction) { + int sessionNum = (num == 10) ? 0 : num; + nb.setCurrentPage(sessionNum - (sessionNum == 0 ? 0 : 1)); + }); } } /** - * Create all the session actions and corresponding actions + * Create the session actions (used to control the current session) */ void createSessionActions(GSettings gsShortcuts) { sessionActions = new SimpleActionGroup(); - //Create Switch to Terminal (0..9) actions - //Can't use :: action targets for this since action name needs to be preferences - for (int i = 0; i <= 9; i++) { - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_TERMINAL_X ~ to!string(i), gsShortcuts, delegate(GVariant, SimpleAction sa) { - Session session = getCurrentSession(); - if (session !is null) { - auto terminalID = to!size_t(sa.getName()[$ - 1 .. $]); - if (terminalID == 0) - terminalID = 10; - session.focusTerminal(terminalID); + saSessionAddRight = registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_ADD_RIGHT, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + getCurrentSession().addTerminal(Orientation.Horizontal); + } + }); + saSessionAddDown = registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_ADD_DOWN, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + getCurrentSession().addTerminal(Orientation.Vertical); + } + }); + saSessionAddAuto = registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_ADD_AUTO, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + getCurrentSession().addAutoOrientedTerminal(); + } + }); + + registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_CLOSE, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + closeSession(getCurrentSession()); + } + }); + + registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_NAME, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + string newName; + if (showInputDialog(this, newName, getCurrentSession().name, _("Session Name"), _("Enter a name for the current session:"))) { + getCurrentSession().name(newName); } - }); - } + } + }); - //Create directional Switch to Terminal actions - const string[] directions = ["up", "down", "left", "right"]; - foreach (string direction; directions) { - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_TERMINAL_X ~ direction, gsShortcuts, delegate(GVariant, SimpleAction sa) { - Session session = getCurrentSession(); - if (session !is null) { - string actionName = sa.getName(); - string direction = actionName[lastIndexOf(actionName, '-') + 1 .. $]; - session.focusDirection(direction); + registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_NEXT_TERMINAL, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + getCurrentSession().focusNext(); + } + }); + + registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_PREV_TERMINAL, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + getCurrentSession().focusPrevious(); + } + }); + + // Register actions for switching to terminal (1-10) + for (int i = 1; i <= 10; i++) { + immutable int num = i; + string actionName = ACTION_SESSION_TERMINAL_X ~ to!string(i); + registerActionWithSettings(sessionActions, ACTION_PREFIX, actionName, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + int termNum = (num == 10) ? 0 : num; + getCurrentSession().focusTerminal(termNum); } }); } - //Create directional Resize to Terminal actions - foreach (string direction; directions) { - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_RESIZE_TERMINAL_DIRECTION ~ direction, gsShortcuts, delegate(GVariant, SimpleAction sa) { - Session session = getCurrentSession(); - if (session !is null) { - string actionName = sa.getName(); - string direction = actionName[lastIndexOf(actionName, '-') + 1 .. $]; - session.resizeTerminal(direction); + // Register actions for resizing terminal in direction + foreach(direction; ["up", "down", "left", "right"]) { + string actionName = ACTION_RESIZE_TERMINAL_DIRECTION ~ direction; + registerActionWithSettings(sessionActions, ACTION_PREFIX, actionName, gsShortcuts, delegate(Variant, SimpleAction) { + if (getCurrentSession() !is null) { + getCurrentSession().resizeTerminal(direction); } }); } - //Add Terminal Actions - saSessionAddRight = registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_ADD_RIGHT, gsShortcuts, delegate(GVariant, SimpleAction) { - Session session = getCurrentSession(); - if (session !is null && !session.maximized) - session.addTerminal(Orientation.HORIZONTAL); - }); - saSessionAddDown = registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_ADD_DOWN, gsShortcuts, delegate(GVariant, SimpleAction) { - Session session = getCurrentSession(); - if (session !is null && !session.maximized) - session.addTerminal(Orientation.VERTICAL); - }); - saSessionAddAuto = registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_ADD_AUTO, gsShortcuts, delegate(GVariant, SimpleAction) { - Session session = getCurrentSession(); - if (session !is null && !session.maximized) - session.addAutoOrientedTerminal(); - }); + saSyncInput = registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_SYNC_INPUT, gsShortcuts, delegate(Variant value, SimpleAction sa) { + bool newState = !sa.getState().getBoolean(); + sa.setState(new GVariant(newState)); + if (getCurrentSession() !is null) { + getCurrentSession().synchronizeInput = newState; + } + }, null, new GVariant(false)); // Initial state: sync input off - /* TODO - GTK doesn't support settings Tab for accelerators, need to look into this more */ - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_NEXT_TERMINAL, gsShortcuts, delegate(GVariant, SimpleAction) { - Session session = getCurrentSession(); - if (session !is null) - session.focusNext(); - }); - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_PREV_TERMINAL, gsShortcuts, delegate(GVariant, SimpleAction) { - Session session = getCurrentSession(); - if (session !is null) - session.focusPrevious(); + registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_SAVE, gsShortcuts, delegate(Variant, SimpleAction) { + saveSession(false); }); - //Close Session - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_CLOSE, gsShortcuts, delegate(GVariant, SimpleAction) { - CumulativeResult!bool results = new CumulativeResult!bool(); - onUserSessionClose(getCurrentSession().uuid, results); + registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_SAVE_AS, gsShortcuts, delegate(Variant, SimpleAction) { + saveSession(true); }); - //Load Session - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_OPEN, gsShortcuts, delegate(GVariant, SimpleAction) { loadSession(); }); - - //Save Session - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_SAVE, gsShortcuts, delegate(GVariant, SimpleAction) { saveSession(false); }); - - //Save As Session - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_SAVE_AS, gsShortcuts, delegate(GVariant, SimpleAction) { saveSession(true); }); - - //Change name of session - registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_NAME, gsShortcuts, delegate(GVariant, SimpleAction) { - Session session = getCurrentSession(); - - MessageDialog dialog = new MessageDialog(this, DialogFlags.MODAL + DialogFlags.USE_HEADER_BAR, MessageType.QUESTION, ButtonsType.OK_CANCEL, _("Enter a new name for the session"), null); - dialog.setTransientFor(this); - dialog.setTitle( _("Change Session Name")); - Entry entry = new Entry(session.name); - entry.setWidthChars(30); - entry.addOnActivate(delegate(Entry) { - dialog.response(ResponseType.OK); - }); - // Note check for Wayland below otherwise popover will clip - if (isWayland(this) && Version.checkVersion(3, 16, 0).length == 0) { - dialog.getMessageArea().add(createTitleEditHelper(entry, TitleEditScope.SESSION)); - } else { - dialog.getMessageArea().add(entry); - } - dialog.setDefaultResponse(ResponseType.OK); - dialog.addOnResponse(delegate(int response, Dialog) { - if (response == ResponseType.OK && entry.getText().length > 0) { - session.name = entry.getText(); - updateTitle(); - } - dialog.hide(); - dialog.destroy(); - }); - dialog.addOnClose(delegate(Dialog dlg) { - dlg.destroy(); - }); - dialog.showAll(); - dialog.present(); + registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_OPEN, gsShortcuts, delegate(Variant, SimpleAction) { + loadSession(); }); - //Synchronize Input - saSyncInput = registerActionWithSettings(sessionActions, ACTION_PREFIX, ACTION_SESSION_SYNC_INPUT, gsShortcuts, delegate(GVariant value, SimpleAction sa) { - bool newState = !sa.getState().getBoolean(); - sa.setState(new GVariant(newState)); - getCurrentSession().synchronizeInput = newState; - mbSessionActions.setActive(false); - }, null, new GVariant(false)); + registerActionWithSettings(sessionActions, "win", ACTION_SESSION_REORDER_PREVIOUS, gsShortcuts, delegate(Variant, SimpleAction) { + reorderCurrentSessionRelative(-1); + }); - insertActionGroup(ACTION_PREFIX, sessionActions); + registerActionWithSettings(sessionActions, "win", ACTION_SESSION_REORDER_NEXT, gsShortcuts, delegate(Variant, SimpleAction) { + reorderCurrentSessionRelative(1); + }); } /** - * Create actions that will be delegated to the active terminal. - * This is required due to a bug in GTK+ < 3.5.15. + * Create delegated terminal actions. * - * https://bugzilla.gnome.org/show_bug.cgi?id=740682 - * https://github.com/gnunn1/tilix/issues/342 + * These are actions that are typically associated with a terminal + * but need to be available at the session level (e.g., for keyboard + * shortcuts when terminal doesn't have focus). */ void createDelegatedTerminalActions(GSettings gsShortcuts) { - import gx.tilix.terminal.terminal : Terminal; - - if (Version.checkVersion(3, 15, 3).length != 0) { - SimpleActionGroup terminalActions = new SimpleActionGroup(); - - foreach (string action; gsShortcuts.listKeys) { - if (action.startsWith("terminal-")) { - logf(LogLevel.trace, "Registering terminal shortcut delegation for action %s", action[9..$]); - registerActionWithSettings(terminalActions, "terminal", action[9..$], gsShortcuts, delegate(GVariant va, SimpleAction sa) { - string terminalUUID = getActiveTerminalUUID(); - logf(LogLevel.trace, "Delegating terminal action '%s' to terminal '%s'", sa.getName(), terminalUUID); - auto terminal = cast(Terminal) findWidgetForUUID(terminalUUID); - if (terminal !is null) { - terminal.triggerAction(sa.getName(), va); - } - }); + import gx.tilix.terminal.actions; + + foreach(actionInfo; terminalDelegatedActions) { + registerActionWithSettings(sessionActions, ACTION_PREFIX_TERMINAL, actionInfo.name, gsShortcuts, delegate(Variant, SimpleAction sa) { + if (getCurrentSession() !is null) { + ITerminal terminal = getCurrentSession().getActiveTerminal(); + if (terminal !is null) { + terminal.executeAction(sa.getName()); + } } - } - - insertActionGroup("terminal", terminalActions); + }); } } /** - * Creates the session action popover + * Creates the popover for the session hamburger menu */ Popover createPopover(Widget parent) { - GMenu model = new GMenu(); - - GMenu mWindowSection = new GMenu(); - mWindowSection.appendItem(new GMenuItem(_("New Window"), getActionDetailedName(ACTION_PREFIX_APP, ACTION_NEW_WINDOW))); - model.appendSection(null, mWindowSection); - - GMenu mFileSection = new GMenu(); - mFileSection.appendItem(new GMenuItem(_("Open…"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_OPEN))); - mFileSection.appendItem(new GMenuItem(_("Save"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_SAVE))); - mFileSection.appendItem(new GMenuItem(_("Save As…"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_SAVE_AS))); -// Remove this since both tabs and sidebar have a close button already -// mFileSection.appendItem(new GMenuItem(_("Close Session"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_CLOSE))); - model.appendSection(null, mFileSection); + GMenu menuModel = new GMenu(); - GMenu mSessionSection = new GMenu(); - mSessionSection.appendItem(new GMenuItem(_("Name…"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_NAME))); - mSessionSection.appendItem(new GMenuItem(_("Synchronize Input"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_SYNC_INPUT))); - model.appendSection(null, mSessionSection); + GMenu sectionSave = new GMenu(); + sectionSave.append(_("_Save"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_SAVE)); + sectionSave.append(_("Save _As..."), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_SAVE_AS)); + sectionSave.append(_("_Open..."), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_OPEN)); + menuModel.appendSection(null, sectionSave); - GMenu mPrefSection = new GMenu(); - mPrefSection.appendItem(new GMenuItem(_("Preferences"), getActionDetailedName(ACTION_PREFIX_APP, ACTION_PREFERENCES))); - mPrefSection.appendItem(new GMenuItem(_("Keyboard Shortcuts"), getActionDetailedName(ACTION_PREFIX_APP, ACTION_SHORTCUTS))); - mPrefSection.append(_("About Tilix"), getActionDetailedName(ACTION_PREFIX_APP, ACTION_ABOUT)); + GMenu sectionSync = new GMenu(); + sectionSync.append(_("S_ynchronize Input"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_SYNC_INPUT)); + menuModel.appendSection(null, sectionSync); + GMenu sectionSession = new GMenu(); + sectionSession.append(_("Session _Name..."), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_NAME)); + sectionSession.append(_("_Close Session"), getActionDetailedName(ACTION_PREFIX, ACTION_SESSION_CLOSE)); + menuModel.appendSection(null, sectionSession); - model.appendSection(null, mPrefSection); - - debug(GC) { - GMenu mDebugSection = new GMenu(); - mDebugSection.appendItem(new GMenuItem(_("GC"), getActionDetailedName("win", "gc"))); - model.appendSection(null, mDebugSection); + GMenu sectionApp = new GMenu(); + sectionApp.append(_("_New Window"), getActionDetailedName(ACTION_PREFIX_APP, ACTION_NEW_WINDOW)); + sectionApp.append(_("_Preferences"), getActionDetailedName(ACTION_PREFIX_APP, ACTION_PREFERENCES)); + if (checkVersion(3, 19, 0) is null) { + sectionApp.append(_("_Keyboard Shortcuts"), getActionDetailedName(ACTION_PREFIX_APP, ACTION_SHORTCUTS)); } + sectionApp.append(_("_About"), getActionDetailedName(ACTION_PREFIX_APP, ACTION_ABOUT)); + menuModel.appendSection(null, sectionApp); - return new Popover(parent, model); + Popover popover = new Popover(parent); + popover.bindModel(menuModel, null); + return popover; } /** - * This is required to get terminal transparency working + * Update the visual to support transparency */ void updateVisual() { Screen screen = getScreen(); Visual visual = screen.getRgbaVisual(); - if (visual && screen.isComposited()) { - trace("Setting rgba visual"); + if (visual !is null) { setVisual(visual); - setAppPaintable(true); - } else { - setVisual(screen.getSystemVisual()); - setAppPaintable(false); } } void createNewSession(string name, string profileUUID, string workingDir) { - //Set firstRun based on whether any sessions currently exist, i.e. no pages in NoteBook - Session session = new Session(name); - session.initSession(profileUUID, workingDir, nb.getNPages() == 0); + Session session = new Session(name, profileUUID, workingDir); + session.onProcessNotification.connect(&onSessionProcessNotification); + session.onUserClose.connect(&onUserSessionClose); addSession(session); } void onPageAdded(Widget page, uint index, Notebook) { - trace("**** Adding page"); - Session session = cast(Session) page; + if (session !is null) { + if (!useTabs) { + sb.addSession(session); + } + session.onStateChange.connect(&onSessionStateChange); + session.onClose.connect(&onSessionClose); + session.onIsActionAllowed.connect(&onIsActionAllowed); + updateUIState(); - session.onClose.connect(&onSessionClose); - session.onAttach.connect(&onSessionAttach); - session.onDetach.connect(&onSessionDetach); - session.onStateChange.connect(&onSessionStateChange); - session.onIsActionAllowed.connect(&onIsActionAllowed); - session.onProcessNotification.connect(&onSessionProcessNotification); - - if (useTabs) { - SessionTabLabel label = cast(SessionTabLabel) nb.getTabLabel(page); - label.onCloseClicked.connect(&closeSession); - nb.setTabReorderable(session, true); - nb.setTabDetachable(session, true); + // Focus terminal after adding the session + session.focusTerminal(1); } } void onPageRemoved(Widget page, uint index, Notebook notebook) { - trace("**** Removing page"); Session session = cast(Session) page; - - //remove event handlers - session.onClose.disconnect(&onSessionClose); - session.onAttach.disconnect(&onSessionAttach); - session.onDetach.disconnect(&onSessionDetach); - session.onStateChange.disconnect(&onSessionStateChange); - session.onIsActionAllowed.disconnect(&onIsActionAllowed); - session.onProcessNotification.disconnect(&onSessionProcessNotification); + if (session !is null) { + if (!useTabs) { + sb.removeSession(session.uuid); + } + updateUIState(); + } } void addSession(Session session) { - int index; - if (!useTabs) { - index = nb.appendPage(session, session.name); + if (useTabs) { + SessionTabLabel label = new SessionTabLabel(PositionType.Top, session.name, session); + label.onCloseClicked.connect(delegate(Session s) { closeSession(s); }); + nb.appendPage(session, label); } else { - SessionTabLabel label = new SessionTabLabel(nb.getTabPos, session.displayName, session); - index = nb.appendPage(session, label); + nb.appendPage(session, new Label(session.name)); } - nb.showAll(); - nb.setCurrentPage(index); - updateUIState(); + nb.setTabReorderable(session, true); + nb.setTabDetachable(session, true); + nb.setCurrentPage(cast(int) nb.getNPages() - 1); } void removeSession(Session session) { - nb.remove(session); - updateUIState(); - //Close Window if there are no pages - if (nb.getNPages() == 0) { - if (gsSettings.getBoolean(SETTINGS_CLOSE_WITH_LAST_SESSION_KEY)) { - trace("No more sessions, closing AppWindow"); - this.close(); - } else { - createSession(); - } + if (session.uuid in sessionNotifications) { + sessionNotifications.remove(session.uuid); + } + + int pageNum = nb.pageNum(session); + if (pageNum >= 0) { + nb.removePage(pageNum); } } Session[] getSessions() { - Session[] result = new Session[](nb.getNPages()); + Session[] sessions; for (int i = 0; i < nb.getNPages(); i++) { - result[i] = getSession(i); + sessions ~= cast(Session) nb.getNthPage(i); } - return result; + return sessions; } Session getSession(int i) { @@ -811,52 +712,40 @@ private: } /** - * Used to handle cases where the user requests a session be closed + * Handle session close request from user */ - void onUserSessionClose(string sessionUUID, CumulativeResult!bool result) { - if (_noPrompt) { - result.addResult(false); + void onUserSessionClose(Session session) { + if (session is null) { return; } - trace("Sidebar requested to close session " ~ sessionUUID); - if (sessionUUID.length > 0) { - Session session = getSession(sessionUUID); - if (session !is null) { - ProcessInformation pi = session.getProcessInformation(); - if (pi.children.length > 0) { - bool canClose = promptCanCloseProcesses(gsSettings, this, pi); - if (!canClose) { - result.addResult(false); - return; - } - } - closeSession(session); - result.addResult(true); + ProcessInformation pi = session.getProcessInformation(); + if (pi.children.length > 0) { + if (!promptCanCloseProcesses(gsSettings, this, pi)) { return; } } - result.addResult(false); - return; + closeSession(session); } void closeSession(Session session) { - //remove session reference from label - if (useTabs) { - SessionTabLabel label = cast(SessionTabLabel) nb.getTabLabel(session); - if (label !is null) { - label.onCloseClicked.disconnect(&closeSession); - label.clear(); + if (session is null) { + return; + } + + // Check for running processes + ProcessInformation pi = session.getProcessInformation(); + if (pi.children.length > 0 && !_noPrompt) { + if (!promptCanCloseProcesses(gsSettings, this, pi)) { + return; } } - bool isCurrentSession = (session == getCurrentSession()); + removeSession(session); - // Don't destroy session artificially due to GtkD issues session.destroy(); - if (!isCurrentSession) { - updateTitle(); - updateUIState(); + + if (nb.getNPages() == 0) { + this.close(); } - trace("Session closed"); } void onSessionClose(Session session) { @@ -864,13 +753,10 @@ private: } void onFileSelected(string file) { - if (file) { - try { - loadSession(file); - } - catch (SessionCreationException e) { - removeRecentSessionFile(file); - showErrorDialog(this, e.msg); + if (file.length > 0) { + loadSession(file); + if (sb !is null) { + saViewSideBar.activate(null); } } } @@ -880,112 +766,98 @@ private: } void onOpenSelected(string uuid) { - if (uuid) { - activateSession(uuid); + if (uuid is null || uuid.length == 0) { + // null/empty UUID means close the sidebar + if (sb !is null) { + sb.reveal(false); + } + return; + } + // Close sidebar first, then activate + if (sb !is null) { + sb.reveal(false); } + activateSession(uuid); } void reorderCurrentSessionRelative(int offset) { - int page = nb.getCurrentPage(); Session session = getCurrentSession(); - nb.reorderChild(session, page + offset); - updateUIState(); + if (session is null) return; + int currentPos = nb.pageNum(session); + nb.reorderChild(session, currentPos + offset); } void onSessionReorder(string sourceUUID, string targetUUID, bool after, CumulativeResult!bool result) { - Session sourceSession = getSession(sourceUUID); - Session targetSession = getSession(targetUUID); - if (sourceSession is null || targetSession is null) { - errorf("Unexpected error for DND, source or target page is null %s, %s", sourceUUID, targetUUID); + Session source = getSession(sourceUUID); + Session target = getSession(targetUUID); + if (source is null || target is null) { result.addResult(false); return; } - int index; - if (!after) { - index = nb.pageNum(targetSession); - } else { - index = nb.pageNum(targetSession); - if (index == nb.getNPages() - 1) index = -1; + int targetPos = nb.pageNum(target); + if (after) { + targetPos++; } - nb.reorderChild(sourceSession, index); + nb.reorderChild(source, targetPos); result.addResult(true); - updateUIState(); } /** - * Invoked by sidebar when user selects a session. + * Called when a session is selected in the sidebar */ void onSessionSelected(string sessionUUID) { - trace("Session selected " ~ sessionUUID); - saViewSideBar.activate(null); - if (sessionUUID.length > 0) { - activateSession(sessionUUID); - } else { - Session session = getCurrentSession(); - if (session !is null) { - getCurrentSession().focusRestore(); - } + Session session = getSession(sessionUUID); + if (session is null) { + return; } + if (!useTabs && sb !is null) { + sb.selectSession(session.uuid); + } + updateTitle(); + updateUIState(); } /** - * Invoked by DND a session on a terminal + * Called when a session is attached from another window */ void onSessionAttach(string sessionUUID) { - + // Helper function to find window containing session AppWindow getWindow(Session session) { - - Widget widget = session.getParent(); - while (widget !is null) { - AppWindow result = cast(AppWindow) widget; - if (result !is null) - return result; - widget = widget.getParent(); + foreach (window; tilix.getAppWindows) { + foreach (s; window.getSessions()) { + if (s is session) { + return window; + } + } } return null; } - Session session = getSession(sessionUUID); - // If session isn't null it already belongs to this window, ignore - if (session !is null) return; - - session = cast(Session) tilix.findWidgetForUUID(sessionUUID); - if (session is null) { - errorf("The session %s could not be located", sessionUUID); - return; - } - - AppWindow sourceWindow = getWindow(session); - if (sourceWindow is null) { - errorf("The AppWindow for session %s could not be located", sessionUUID); - return; + foreach (window; tilix.getAppWindows) { + Session session = window.getSession(sessionUUID); + if (session !is null && window !is this) { + window.removeSession(session); + addSession(session); + return; + } } - - sourceWindow.removeSession(session); - addSession(session); } AppWindow cloneWindow() { - AppWindow result = new AppWindow(tilix, useTabs); - tilix.addAppWindow(result); - - result.setDefaultSize(getAllocatedWidth(), getAllocatedHeight()); - if (isMaximized) result.maximize(); - return result; + AppWindow window = new AppWindow(tilix, useTabs); + window.initialize(); + window.showAll(); + return window; } - /* - * Event occurs when tab is detached from notebook + /** + * Called when a tab is dragged to create a new window */ Notebook onCreateWindow(Widget page, int x, int y, Notebook) { - trace("Detaching tab, create new window"); - SessionTabLabel label = cast(SessionTabLabel) nb.getTabLabel(page); - if (label !is null) { - label.onCloseClicked.disconnect(&closeSession); - } AppWindow window = cloneWindow(); - window.move(x, y); - window.showAll(); + if (x >= 0 && y >= 0) { + window.move(x, y); + } return window.nb; } @@ -993,199 +865,195 @@ private: Session session = getSession(sessionUUID); if (session !is null) { onSessionDetach(session, x, y, false); - } else { - errorf("Could not locate session for %s", sessionUUID); } } void onSessionDetach(Session session, int x, int y, bool isNewSession) { - trace("Detaching session"); - //Detach an existing session, let's close it - if (!isNewSession) { - removeSession(session); - } - AppWindow window = cloneWindow();//new AppWindow(tilix); - tilix.addAppWindow(window); - window.initialize(session); - window.move(x, y); - window.showAll(); + if (session is null) { + return; + } + removeSession(session); + AppWindow window = cloneWindow(); + window.addSession(session); + if (x >= 0 && y >= 0) { + window.move(x, y); + } } void onSessionStateChange(Session session, SessionStateChange stateChange) { - //tracef("State change received %d", stateChange); - if (getCurrentSession() == session) { - updateUIState(); - updateTitle(); - if (stateChange == SessionStateChange.TERMINAL_FOCUSED) { - Signals.handlerBlock(tbFind, _tbFindToggledId); - tbFind.setActive(getActiveTerminal().isFindToggled()); - Signals.handlerUnblock(tbFind, _tbFindToggledId); - } - } - if (useTabs) { - if (((stateChange == SessionStateChange.TERMINAL_TITLE) || (stateChange == SessionStateChange.SESSION_TITLE)) || (stateChange == SessionStateChange.TERMINAL_FOCUSED)) { - SessionTabLabel label = cast(SessionTabLabel) nb.getTabLabel(session); - if (label !is null) label.text=session.displayName; - } - if (getCurrentSession() != session && stateChange == SessionStateChange.TERMINAL_OUTPUT) { - SessionTabLabel label = cast(SessionTabLabel) nb.getTabLabel(session); - if (label !is null) label.showNewOutput(true); - } + final switch (stateChange) { + case SessionStateChange.NAME: + if (useTabs) { + SessionTabLabel label = cast(SessionTabLabel) nb.getTabLabel(session); + if (label !is null) { + label.text = session.name; + } + } + updateTitle(); + break; + case SessionStateChange.TERMINAL_FOCUSED: + updateTitle(); + break; + case SessionStateChange.TERMINAL_TITLE: + updateTitle(); + break; + case SessionStateChange.FIND: + if (session is getCurrentSession()) { + // Update find button state + signalHandlerBlock(tbFind, _tbFindToggledId); + tbFind.setActive(session.isSearching()); + signalHandlerUnblock(tbFind, _tbFindToggledId); + } + break; + case SessionStateChange.TERMINAL_MAXIMIZED: + case SessionStateChange.TERMINAL_RESTORED: + case SessionStateChange.TERMINAL_OUTPUT: + case SessionStateChange.SESSION_TITLE: + // Handle these state changes as needed + break; } } void updateUIState() { - if (!useTabs) { - tbSideBar.queueDraw(); + int numSessions = nb.getNPages(); + int currentPage = nb.getCurrentPage(); + + // Update sidebar label + if (lblSideBar !is null) { + lblSideBar.setText(format("%d / %d", currentPage + 1, numSessions)); } - //saCloseSession.setEnabled(nb.getNPages > 1); - Session session = getCurrentSession(); - if (session !is null) { - saSessionAddRight.setEnabled(!session.maximized); - saSessionAddDown.setEnabled(!session.maximized); + + // Update session action sensitivity + // Use getNPages() > 0 instead of getCurrentSession() because during onPageAdded + // the page is added but setCurrentPage hasn't been called yet + bool hasSession = nb.getNPages() > 0; + if (saSyncInput !is null) { + saSyncInput.setEnabled(hasSession); } - if (useTabs) { - nb.setShowTabs(nb.getNPages() > 1); - for (int i = 0; i < nb.getNPages(); i++) { - Session s = getSession(i); - SessionTabLabel label = cast(SessionTabLabel) nb.getTabLabel(s); - if (label is null) continue; - if (s.uuid in sessionNotifications) { - label.updateNotifications(sessionNotifications[s.uuid].messages); - } else { - label.clearNotifications(); - } - } - } else { - lblSideBar.setLabel(format("%d / %d", nb.getCurrentPage() + 1, nb.getNPages())); + if (saSessionAddRight !is null) { + saSessionAddRight.setEnabled(hasSession); + } + if (saSessionAddDown !is null) { + saSessionAddDown.setEnabled(hasSession); + } + if (saSessionAddAuto !is null) { + saSessionAddAuto.setEnabled(hasSession); + } + + // Update notifications + if (!useTabs && sb !is null) { + sb.updateNotifications(sessionNotifications); } } void updateTitle() { string title = getDisplayTitle(); - if (!isCSDDisabled()) { - if (cTitle !is null) { - cTitle.title = title; - } else { - hb.setTitle(title); - } + if (cTitle !is null) { + cTitle.setTitle(title); } setTitle(title); } string getDisplayTitle() { - string title = _overrideTitle.length == 0?gsSettings.getString(SETTINGS_APP_TITLE_KEY):_overrideTitle; + import std.string : replace; + + string title = _overrideTitle.length == 0 ? gsSettings.getString(SETTINGS_APP_TITLE_KEY) : _overrideTitle; title = title.replace(VARIABLE_APP_NAME, _(APPLICATION_NAME)); Session session = getCurrentSession(); - if (session) { + if (session !is null) { title = session.getDisplayText(title); - title = title.replace(VARIABLE_SESSION_NUMBER, to!string(nb.getCurrentPage()+1)); + title = title.replace(VARIABLE_SESSION_NUMBER, to!string(nb.getCurrentPage() + 1)); title = title.replace(VARIABLE_SESSION_COUNT, to!string(nb.getNPages())); title = title.replace(VARIABLE_SESSION_NAME, session.displayName); } else { - title = title.replace(VARIABLE_SESSION_NUMBER, to!string(nb.getCurrentPage()+1)); + title = title.replace(VARIABLE_SESSION_NUMBER, to!string(nb.getCurrentPage() + 1)); title = title.replace(VARIABLE_SESSION_COUNT, to!string(nb.getNPages())); title = title.replace(VARIABLE_SESSION_NAME, _("Default")); } return title; } - bool drawSideBarBadge(Scoped!Context cr, Widget widget) { - - // pw, ph, ps = percent width, height, size + bool drawSideBarBadge(Context cr, Widget widget) { + // Nested function for drawing badge void drawBadge(double pw, double ph, double ps, RGBA fg, RGBA bg, int value) { - int w = widget.getAllocatedWidth(); - int h = widget.getAllocatedHeight(); - - double x = w * pw; - double y = h * ph; - double radius = min(w,h) * ps; + string text = to!string(value); + double radius = ps / 2; + double x = pw - ps; + double y = 2; - cr.save(); cr.setSourceRgba(bg.red, bg.green, bg.blue, bg.alpha); - cr.arc(x, y, radius, 0.0, 2.0 * PI); - cr.fillPreserve(); - cr.stroke(); - cr.selectFontFace("monospace", cairo_font_slant_t.NORMAL, cairo_font_weight_t.NORMAL); + cr.arc(x + radius, y + radius, radius, 0, 2 * PI); + cr.fill(); + + cr.setSourceRgba(fg.red, fg.green, fg.blue, fg.alpha); + cr.selectFontFace("Sans", FontSlant.Normal, FontWeight.Bold); cr.setFontSize(10); - cr.setSourceRgba(fg.red, fg.green, fg.blue, 1.0); - string text = to!string(value); - cairo_text_extents_t extents; - cr.textExtents(text, &extents); - cr.moveTo(x - extents.width / 2, y + extents.height / 2); + TextExtents extents; + cr.textExtents(text, extents); + cr.moveTo(x + radius - extents.width / 2, y + radius + extents.height / 2); cr.showText(text); - cr.restore(); - cr.newPath(); } - RGBA fg; - RGBA bg; - //Draw number of notifications on button - ulong count = 0; - foreach (sn; sessionNotifications.values) { - count = count + sn.messages.length; + int totalNotifications = 0; + foreach (sn; sessionNotifications.byValue()) { + totalNotifications += cast(int) sn.messages.length; } - if (count > 0) { - widget.getStyleContext().lookupColor("theme_selected_fg_color", fg); - widget.getStyleContext().lookupColor("theme_selected_bg_color", bg); - bg.alpha = 0.9; - drawBadge(0.87, 0.68, 0.15, fg, bg, to!int(count)); + + if (totalNotifications > 0) { + RGBA fg, bg; + fg.parse("#FFFFFF"); + bg.parse("#CC0000"); + drawBadge(widget.getAllocatedWidth(), widget.getAllocatedHeight(), 16, fg, bg, totalNotifications); } + return false; } void onIsActionAllowed(ActionType actionType, CumulativeResult!bool result) { final switch (actionType) { case ActionType.DETACH_TERMINAL: - // Only allow if there is more then one session, note that session - // checks if there is more then one terminal and allows in either case - result.addResult( nb.getNPages() > 1); + result.addResult(true); break; case ActionType.DETACH_SESSION: - // Only allow if there is more then one session - result.addResult( nb.getNPages() > 1); + result.addResult(nb.getNPages() > 1); + break; + case ActionType.SPLIT_HORIZONTAL: + case ActionType.SPLIT_VERTICAL: + case ActionType.SPLIT_AUTO: + result.addResult(true); break; } - return; } - - void sendNotification(string id, string summary, string _body, ) { - Notification n = new Notification(summary); - n.setBody(_body); - tracef("Sending notification %s", id); - getApplication().sendNotification(id, n); + void sendNotification(string id, string summary, string _body) { + Notification notification = new Notification(summary); + notification.setBody(_body); + tilix.sendNotification(id, notification); } void onSessionProcessNotification(string summary, string _body, string terminalUUID, string sessionUUID) { - tracef("Notification Received\n\tSummary=%s\n\tBody=%s", summary, _body); - // If window not active, send notification to shell - if (!isActive() && !_destroyed && gsSettings.getBoolean(SETTINGS_NOTIFY_ON_PROCESS_COMPLETE_KEY)) { - string uuid = terminalUUID.length == 0? sessionUUID:terminalUUID; - Notification n = new Notification(_(summary)); - n.setBody(_body); - n.setDefaultAction("app.activate-session::" ~ sessionUUID); - tracef("Sending notification %s", uuid); - getApplication().sendNotification(uuid, n); - //if session not visible send to local handler - } - // If session not active, keep copy locally - if (sessionUUID != getCurrentSession().uuid) { - tracef("SessionUUID: %s versusterminal. Notification UUID: %s", sessionUUID, getCurrentSession().uuid); - //handle session level notifications here - ProcessNotificationMessage msg = ProcessNotificationMessage(terminalUUID, summary, _body); - if (sessionUUID in sessionNotifications) { - SessionNotification sn = sessionNotifications[sessionUUID]; - sn.messages ~= msg; - trace("Updated with new notification " ~ to!string(sn.messages.length)); - } else { - SessionNotification sn = new SessionNotification(sessionUUID); - sn.messages ~= msg; - sessionNotifications[sessionUUID] = sn; - trace("Session UUID " ~ sn.sessionUUID); - trace("Messages " ~ to!string(sn.messages.length)); - } - updateUIState(); + tracef("Process notification: %s - %s", summary, _body); + if (isActive()) { + // Window is active, don't show notification + return; + } + + auto msg = ProcessNotificationMessage(terminalUUID, summary, _body); + + if (sessionUUID in sessionNotifications) { + sessionNotifications[sessionUUID].messages ~= msg; + } else { + auto sn = new SessionNotification(sessionUUID); + sn.messages ~= msg; + sessionNotifications[sessionUUID] = sn; } + + // Send desktop notification + Notification notification = new Notification(summary); + notification.setBody(_body); + notification.setDefaultAction("app.activate-terminal('" ~ terminalUUID ~ "')"); + tilix.sendNotification(uuid ~ "-" ~ terminalUUID, notification); + + updateUIState(); } bool onWindowClosed(Event event, Widget widget) { @@ -1206,7 +1074,7 @@ private: tilix.removeAppWindow(this); sessionActions.destroy(); sessionActions = null; - saSyncInput = null; + saSyncInput = null; saViewSideBar = null; saSessionAddRight = null; saSessionAddDown = null; @@ -1232,15 +1100,15 @@ private: getCurrentSession().focusTerminal(1); } } else if (tilix.getGlobalOverrides().geometry.flag == GeometryFlag.NONE && !isWayland(this) && gsSettings.getBoolean(SETTINGS_WINDOW_SAVE_STATE_KEY)) { - GdkWindowState state = cast(GdkWindowState)gsSettings.getInt(SETTINGS_WINDOW_STATE_KEY); - if (state & GdkWindowState.MAXIMIZED) { + WindowState state = cast(WindowState)gsSettings.getInt(SETTINGS_WINDOW_STATE_KEY); + if (state & WindowState.Maximized) { maximize(); - } else if (state & GdkWindowState.ICONIFIED) { + } else if (state & WindowState.Iconified) { iconify(); - } else if (state & GdkWindowState.FULLSCREEN) { + } else if (state & WindowState.Fullscreen) { fullscreen(); } - if (state & GdkWindowState.STICKY) { + if (state & WindowState.Sticky) { stick(); } } @@ -1248,207 +1116,151 @@ private: void onWindowRealized(Widget) { if (isQuake()) { - applyPreference(SETTINGS_QUAKE_HEIGHT_PERCENT_KEY); - } else { - handleGeometry(); + // Handle quake-specific realization } } bool handleGeometry() { - if (!isQuake() && tilix.getGlobalOverrides().geometry.flag == GeometryFlag.FULL && !isWayland(this)) { - int x, y; - Geometry geometry = tilix.getGlobalOverrides().geometry; - Gravity gravity = Gravity.NORTH_WEST; - int width = nb.getAllocatedWidth(); - int height = nb.getAllocatedHeight(); - if (!geometry.xNegative) - x = geometry.x; - else { - x = getScreen().getWidth() - width + geometry.x; - gravity = Gravity.NORTH_EAST; + CommandParameters params = tilix.getGlobalOverrides(); + if (params.geometry.flag != GeometryFlag.NONE) { + if (params.geometry.flag == GeometryFlag.PARTIAL || params.geometry.flag == GeometryFlag.FULL) { + // Size is handled by session/terminal } - - if (!geometry.yNegative) - y = geometry.y; - else { - y = getScreen().getHeight() - height + geometry.y; - gravity = (geometry.xNegative) ? Gravity.SOUTH_EAST : Gravity.SOUTH_WEST; + if (params.geometry.flag == GeometryFlag.FULL) { + if (!isWayland(this)) { + move(params.geometry.x, params.geometry.y); + } } - setGravity(gravity); - move(x, y); return true; } + + // Window size restoration not implemented (no gsettings keys defined) return false; } void onCompositedChanged(Widget) { - trace("Composite changed"); - updateVisual(); + if (gsSettings.getBoolean(SETTINGS_ENABLE_TRANSPARENCY_KEY)) { + updateVisual(); + } } void updateTabPosition() { - if (useTabs) { - if (isQuake) { - nb.setTabPos(cast(GtkPositionType) gsSettings.getEnum(SETTINGS_QUAKE_TAB_POSITION_KEY)); - } else { - nb.setTabPos(cast(GtkPositionType) gsSettings.getEnum(SETTINGS_TAB_POSITION_KEY)); - } - for (int i=0; i=0 && altMonitor < getScreen().getNMonitors()) { - monitor = altMonitor; - } else { - monitor = getScreen().getPrimaryMonitor(); - } - } + int monitor = gsSettings.getInt(SETTINGS_QUAKE_ACTIVE_MONITOR_KEY); + if (monitor < 0 || monitor >= screen.getNMonitors()) { + monitor = screen.getPrimaryMonitor(); } - screen.getMonitorWorkarea(monitor, rect); - tracef("Monitor geometry: monitor=%d, x=%d, y=%d, width=%d, height=%d", monitor, rect.x, rect.y, rect.width, rect.height); + Rectangle monitorRect; + screen.getMonitorWorkarea(monitor, monitorRect); - // Wayland works with screen factor natively whereas X11 does not - int scaleFactor = screen.getMonitorScaleFactor(monitor); - if (wayland && scaleFactor > 1) { - rect.width = rect.width / scaleFactor; - rect.height = rect.height / scaleFactor; - tracef("Scaled monitor geometry: monitor=%d, scaleFactor=%d, x=%d, y=%d, width=%d, height=%d", monitor, scaleFactor, rect.x, rect.y, rect.width, rect.height); - } + int heightPercent = gsSettings.getInt(SETTINGS_QUAKE_HEIGHT_PERCENT_KEY); + int widthPercent = gsSettings.getInt(SETTINGS_QUAKE_WIDTH_PERCENT_KEY); + string alignment = gsSettings.getString(SETTINGS_QUAKE_ALIGNMENT_KEY); - double widthPercent = to!double(gsSettings.getInt(SETTINGS_QUAKE_WIDTH_PERCENT_KEY))/100.0; - double heightPercent = to!double(gsSettings.getInt(SETTINGS_QUAKE_HEIGHT_PERCENT_KEY))/100.0; - if (wayland) { - widthPercent = 1; - } + rect.width = cast(int)(monitorRect.width * widthPercent / 100.0); + rect.height = cast(int)(monitorRect.height * heightPercent / 100.0); + rect.y = monitorRect.y; - if (widthPercent == 1 && heightPercent == 1) { - maximize(); - return; - } - - // Calculate Height and offset for bottom positioning - int height = to!int(rect.height * heightPercent); - if (!wayland && heightPercent < 1 && gsSettings.getString(SETTINGS_QUAKE_WINDOW_POSITION_KEY)==SETTINGS_QUAKE_WINDOW_POSITION_VALUES[1]) { - rect.y = rect.height - height; - } - rect.height = height; - - //Width - // Window only gets positioned properly in Wayland when width is 100%, - // not sure if this kludge is really a good idea and will work consistently. - if (widthPercent < 1) { - int width = to!int(rect.width * widthPercent); - tracef("Calculated width %d", width); - switch (gsSettings.getString(SETTINGS_QUAKE_ALIGNMENT_KEY)) { - case SETTINGS_QUAKE_ALIGNMENT_LEFT_VALUE: - break; - case SETTINGS_QUAKE_ALIGNMENT_CENTER_VALUE: - rect.x = rect.x + (rect.width - width)/2; - break; - case SETTINGS_QUAKE_ALIGNMENT_RIGHT_VALUE: - rect.x = rect.x + rect.width - width; - break; - default: - break; - } - rect.width = width; + switch (alignment) { + case "left": + rect.x = monitorRect.x; + break; + case "right": + rect.x = monitorRect.x + monitorRect.width - rect.width; + break; + case "center": + default: + rect.x = monitorRect.x + (monitorRect.width - rect.width) / 2; + break; } - tracef("Quake window: monitor=%d, x=%d, y=%d, width=%d, height=%d", monitor, rect.x, rect.y, rect.width, rect.height); } Session getCurrentSession() { - if (nb.getCurrentPage < 0) + int currentPage = nb.getCurrentPage(); + if (currentPage < 0) { return null; - else - return getSession(nb.getCurrentPage()); + } + return cast(Session) nb.getNthPage(currentPage); } Session getSession(string sessionUUID) { for (int i = 0; i < nb.getNPages(); i++) { - Session session = getSession(i); - if (session.uuid == sessionUUID) { + Session session = cast(Session) nb.getNthPage(i); + if (session !is null && session.uuid == sessionUUID) { return session; } } @@ -1456,163 +1268,142 @@ private: } void addFilters(FileChooserDialog fcd) { - FileFilter ff = new FileFilter(); - ff.addPattern("*.json"); - ff.setName(_("All JSON Files")); - fcd.addFilter(ff); - ff = new FileFilter(); - ff.addPattern("*"); - ff.setName(_("All Files")); - fcd.addFilter(ff); + FileFilter filterJson = new FileFilter(); + filterJson.setName(_("Tilix session files (*.json)")); + filterJson.addPattern("*.json"); + fcd.addFilter(filterJson); + + FileFilter filterAll = new FileFilter(); + filterAll.setName(_("All files")); + filterAll.addPattern("*"); + fcd.addFilter(filterAll); } /** - * Loads session from a file + * Load a session from file */ void loadSession(string filename) { - if (!exists(filename)) - throw new SessionCreationException(format(_("Filename '%s' does not exist"), filename)); - string text = readText(filename); - JSONValue value = parseJSON(text); - int width = nb.getAllocatedWidth(); - int height = nb.getAllocatedHeight(); - // If no sessions then we are loading our first session, - // set the window size to what was saved in session JSON file - if (!nb.getRealized()) { - try { - Session.getPersistedSessionSize(value, width, height); - if (nb.getNPages() == 0) { - setDefaultSize(width, height); - } - } - catch (Exception e) { - throw new SessionCreationException("Session could not be created due to error: " ~ e.msg, e); - } + if (!exists(filename)) { + showErrorDialog(this, format(_("File not found: %s"), filename)); + return; } - addRecentSessionFile(filename); - tracef("Session dimensions: w=%d, h=%d", width, height); - Session session = new Session(""); - session.initSession(value, filename, width, height, nb.getNPages() == 0); - addSession(session); - } - FileChooserDialog fcd; + try { + string content = readText(filename); + JSONValue json = parseJSON(content); + int width, height; + Session.getPersistedSessionSize(json, width, height); + string sessionName = json["name"].str(); + Session session = new Session(sessionName); + session.initSession(json, filename, width, height, false); + session.onProcessNotification.connect(&onSessionProcessNotification); + session.onUserClose.connect(&onUserSessionClose); + addSession(session); + addRecentSessionFile(filename); + } catch (Exception e) { + showErrorDialog(this, format(_("Error loading session: %s"), e.msg)); + } + } /** - * Loads session from a file, prompt user to select file + * Show file chooser dialog for loading session */ void loadSession() { - fcd = new FileChooserDialog( - _("Load Session"), - this, - FileChooserAction.OPEN, - [_("Open"), _("Cancel")]); + import gtk.c.functions : gtk_file_chooser_dialog_new; + import gtk.c.types : GtkFileChooserAction, GtkWidget, GtkWindow; + import std.string : toStringz; + + GtkWidget* widget = gtk_file_chooser_dialog_new( + toStringz(_("Open Session")), + cast(GtkWindow*) _cPtr(), + GtkFileChooserAction.Open, + toStringz(_("_Cancel")), ResponseType.Cancel, + toStringz(_("_Open")), ResponseType.Accept, + null + ); + FileChooserDialog fcd = new FileChooserDialog(cast(void*) widget, No.Take); + scope(exit) fcd.destroy(); + + addFilters(fcd); + if (DialogPath.LOAD_SESSION in dialogPaths) { fcd.setCurrentFolder(dialogPaths[DialogPath.LOAD_SESSION]); + } else { + fcd.setCurrentFolder(getHomeDir()); } - fcd.setModal(true); - fcd.setTransientFor(this); - addFilters(fcd); - fcd.setSelectMultiple(true); - fcd.addOnResponse(delegate(int response, Dialog) { - if (response == ResponseType.OK) { - try { - string[] filenames = fcd.getFilenames().toArray!string(); - foreach(filename; filenames) { - loadSession(filename); - addRecentSessionFile(filename); - } - dialogPaths[DialogPath.LOAD_SESSION] = fcd.getCurrentFolder(); - } - catch (Exception e) { - fcd.hide(); - removeRecentSessionFile(fcd.getFilename()); - error(e); - showErrorDialog(this, _("Could not load session due to unexpected error.") ~ "\n" ~ e.msg, _("Error Loading Session")); - } - } - fcd.hide(); - fcd.destroy(); - }); - fcd.addOnClose(delegate(Dialog) { - fcd.destroy(); - fcd = null; - }); - fcd.present(); + if (fcd.run() == ResponseType.Accept) { + string filename = fcd.getFilename(); + dialogPaths[DialogPath.LOAD_SESSION] = fcd.getCurrentFolder(); + loadSession(filename); + } } /** - * Saves session to a file - * - * Params: - * showSaveAsDialog = Determines if save as dialog is shown. Note dialog may be shown even if false is passed if the session filename is not set + * Save the current session to file */ void saveSession(bool showSaveAsDialog = true) { Session session = getCurrentSession(); - if (session !is null && (session.filename.length <= 0 || showSaveAsDialog)) { - fcd = new FileChooserDialog( - _("Save Session"), - this, - FileChooserAction.SAVE, - [_("Save"), _("Cancel")]); - fcd.setModal(true); - fcd.setTransientFor(this); + if (session is null) { + return; + } - addFilters(fcd); + string filename; + if (showSaveAsDialog || session.filename.length == 0) { + import gtk.c.functions : gtk_file_chooser_dialog_new; + import gtk.c.types : GtkFileChooserAction, GtkWidget, GtkWindow; + import std.string : toStringz; + + GtkWidget* widget = gtk_file_chooser_dialog_new( + toStringz(_("Save Session")), + cast(GtkWindow*) _cPtr(), + GtkFileChooserAction.Save, + toStringz(_("_Cancel")), ResponseType.Cancel, + toStringz(_("_Save")), ResponseType.Accept, + null + ); + FileChooserDialog fcd = new FileChooserDialog(cast(void*) widget, No.Take); + scope(exit) fcd.destroy(); fcd.setDoOverwriteConfirmation(true); - fcd.setDefaultResponse(ResponseType.OK); + addFilters(fcd); + if (session.filename.length > 0) { - fcd.setCurrentFolder(dirName(session.filename)); - fcd.setCurrentName(session.filename.length > 0 ? baseName(session.filename) : session.displayName ~ ".json"); - } else if (DialogPath.SAVE_SESSION in dialogPaths) { - fcd.setCurrentFolder(dialogPaths[DialogPath.SAVE_SESSION]); + fcd.setFilename(session.filename); + } else { + if (DialogPath.SAVE_SESSION in dialogPaths) { + fcd.setCurrentFolder(dialogPaths[DialogPath.SAVE_SESSION]); + } else { + fcd.setCurrentFolder(getHomeDir()); + } + fcd.setCurrentName(session.name ~ ".json"); } - fcd.addOnResponse(delegate(int response, Dialog) { - if (response == ResponseType.OK) { - try { - string filename = fcd.getFilename(); - if (!filename.endsWith(".json")) { - filename ~= ".json"; - } - dialogPaths[DialogPath.SAVE_SESSION] = fcd.getCurrentFolder(); - addRecentSessionFile(filename); - string json = session.serialize().toPrettyString(); - write(filename, json); - session.filename = filename; - } - catch (Exception e) { - fcd.hide(); - removeRecentSessionFile(fcd.getFilename()); - error(e); - showErrorDialog(this, _("Could not save session due to unexpected error.") ~ "\n" ~ e.msg, _("Error Saving Session")); - } - } - fcd.hide(); - fcd.destroy(); - }); - fcd.addOnClose(delegate(Dialog) { - fcd.destroy(); - fcd = null; - }); - fcd.present(); - } - else { - try { - string json = session.serialize().toPrettyString(); - write(session.filename, json); + if (fcd.run() != ResponseType.Accept) { + return; } - catch (Exception e) { - error(e); - showErrorDialog(this, _("Could not save session due to unexpected error.") ~ "\n" ~ e.msg, _("Error Saving Session")); + filename = fcd.getFilename(); + dialogPaths[DialogPath.SAVE_SESSION] = fcd.getCurrentFolder(); + + if (!filename.endsWith(".json")) { + filename ~= ".json"; } + } else { + filename = session.filename; + } + + try { + JSONValue json = session.serialize(); + std.file.write(filename, json.toPrettyString()); + session.filename = filename; + addRecentSessionFile(filename); + } catch (Exception e) { + showErrorDialog(this, format(_("Error saving session: %s"), e.msg)); } } /** - * Creates a new session based on parameters, user is not prompted + * Create a new session (public method) */ void createSession(string name, string profileUUID, string workingDir = null) { createNewSession(name, profileUUID, workingDir); @@ -1627,54 +1418,64 @@ private: } /** - * Prepends a file path to the recent session files list + * Add a file to the recent session files list */ void addRecentSessionFile(string path, bool save = true) { - // Don't save after removing as the list will be saved later - removeRecentSessionFile(path, false); - + // Remove if already in list + recentSessionFiles = recentSessionFiles.filter!(a => a != path).array; + // Add to front recentSessionFiles = path ~ recentSessionFiles; - + // Limit list size + if (recentSessionFiles.length > 10) { + recentSessionFiles = recentSessionFiles[0..10]; + } if (save) { saveRecentSessionFileList(); } } /** - * Removes a file path from from the recent session files list + * Remove a file from the recent session files list */ void removeRecentSessionFile(string path, bool save = true) { - string[] temp; - - foreach (i, string aPath; recentSessionFiles) { - if (aPath != path) { - temp ~= aPath; - } - } - - recentSessionFiles = temp; - + recentSessionFiles = recentSessionFiles.filter!(a => a != path).array; if (save) { saveRecentSessionFileList(); } + if (sb !is null) { + sb.updateRecentFiles(recentSessionFiles); + } } void removeTimeout() { if (timeoutID > 0) { - g_source_remove(timeoutID); + import glib.source : Source; + Source.remove(timeoutID); timeoutID = 0; } } void setWindowStyle() { - windowStyle = gsSettings.getEnum(SETTINGS_WINDOW_STYLE_KEY); + string style = gsSettings.getString(SETTINGS_WINDOW_STYLE_KEY); + // Override from command line if (tilix.getGlobalOverrides().windowStyle.length > 0) { - foreach(i, style; SETTINGS_WINDOW_STYLE_VALUES) { - if (style == tilix.getGlobalOverrides().windowStyle) { - windowStyle = i; - break; - } - } + style = tilix.getGlobalOverrides().windowStyle; + } + switch (style) { + case "normal": + windowStyle = 0; + break; + case "disable-csd": + windowStyle = 1; + break; + case "disable-csd-hide-toolbar": + windowStyle = 2; + break; + case "borderless": + windowStyle = 3; + break; + default: + windowStyle = 0; } } @@ -1688,14 +1489,14 @@ public: this.useTabs = useTabs; tilix.addAppWindow(this); gsSettings = new GSettings(SETTINGS_ID); - gsSettings.addOnChanged(delegate(string key, GSettings) { + gsSettings.connectChanged(null, delegate(string key, Settings settings) { applyPreference(key); }); setTitle(_("Tilix")); setIconName("com.gexperts.Tilix"); setWindowStyle(); loadRecentSessionFileList(); - gsSettings.addOnChanged(delegate(string key, GSettings) { + gsSettings.connectChanged(null, delegate(string key, Settings settings) { if (key == SETTINGS_RECENT_SESSION_FILES_KEY) { loadRecentSessionFileList(); } else if (key == SETTINGS_APP_TITLE_KEY) { @@ -1709,14 +1510,11 @@ public: if (tilix.getGlobalOverrides().quake && !isWayland(null)) { _quake = true; setDecorated(false); - // Todo: Should this be NORTH instead? - setGravity(GdkGravity.STATIC); + setGravity(Gravity.Static); setSkipTaskbarHint(true); setSkipPagerHint(true); applyPreference(SETTINGS_QUAKE_HEIGHT_PERCENT_KEY); applyPreference(SETTINGS_QUAKE_SHOW_ON_ALL_WORKSPACES_KEY); - // On Ubuntu this causes terminal to use default size, see #602 - //setResizable(false); setRole("quake"); } else { if (tilix.getGlobalOverrides.quake) { @@ -1732,19 +1530,12 @@ public: createUI(); - addOnDelete(&onWindowClosed); - addOnDestroy(&onWindowDestroyed); - addOnRealize(&onWindowRealized); - /* - addOnMap(delegate(Widget) { - if (isQuake()) { - applyPreference(SETTINGS_QUAKE_DISABLE_ANIMATION_KEY); - } - }, ConnectFlags.AFTER); - */ + connectDeleteEvent(&onWindowClosed); + connectDestroy(&onWindowDestroyed); + connectRealize(&onWindowRealized); - addOnShow(&onWindowShow, ConnectFlags.AFTER); - addOnSizeAllocate(delegate(GdkRectangle* rect, Widget) { + connectShow(&onWindowShow, Yes.After); + connectSizeAllocate(delegate(Allocation rect, Widget w) { if (lastWidth != rect.width || lastHeight != rect.height) { //invalidate rendered background if (isBGImage !is null) { @@ -1754,25 +1545,23 @@ public: lastWidth = rect.width; lastHeight = rect.height; } - }, ConnectFlags.AFTER); - addOnCompositedChanged(&onCompositedChanged); - addOnFocusOut(delegate(Event e, Widget widget) { + }, Yes.After); + connectCompositedChanged(&onCompositedChanged); + connectFocusOutEvent(delegate(EventFocus e, Widget widget) { if (isQuake && gsSettings.getBoolean(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_KEY)) { Window window = tilix.getActiveWindow(); if (window !is null) { - if (window.getWindowStruct() == this.getWindowStruct()) { - ListG list = window.listToplevels(); - Window[] windows = list.toArray!(Window)(); - tracef("Top level windows = %d", windows.length); - foreach(Window child; windows) { + if (window._cPtr() == this._cPtr()) { + Widget[] widgets = window.listToplevels(); + tracef("Top level windows = %d", widgets.length); + foreach(Widget child; widgets) { Dialog dialog = cast(Dialog)child; - if (dialog !is null && dialog.getTransientFor() !is null && dialog.getTransientFor().getWindowStruct() == this.getWindowStruct()) return false; + if (dialog !is null && dialog.getTransientFor() !is null && dialog.getTransientFor()._cPtr() == this._cPtr()) return false; } } } trace("Focus lost, waiting to hide quake window"); - // store a reference to this timeout so that it may be canceled if we regain focus timeoutID = threadsAddTimeoutDelegate(gsSettings.getInt(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_DELAY_KEY), delegate() { trace("Focus lost and timeout reached, hiding quake window"); if (isVisible()) { @@ -1782,9 +1571,8 @@ public: }); } return false; - }, ConnectFlags.AFTER); - addOnFocusIn(delegate(Event e, Widget widget) { - // if we're restoring focus to quake window, we want to keep it open + }, Yes.After); + connectFocusInEvent(delegate(EventFocus e, Widget widget) { removeTimeout(); tilix.withdrawNotification(uuid); @@ -1793,13 +1581,17 @@ public: } return false; }); - addOnWindowState(delegate(GdkEventWindowState* state, Widget) { + connectWindowStateEvent(delegate(EventWindowState event, Widget w) { trace("Window state changed"); - if ((state.newWindowState & GdkWindowState.FULLSCREEN) == GdkWindowState.FULLSCREEN) { + if (event is null) { + return false; + } + WindowState newState = event.newWindowState; + if ((newState & WindowState.Fullscreen) == WindowState.Fullscreen) { trace("Window state is fullscreen"); } if (getWindow() !is null && !isQuake() && gsSettings.getBoolean(SETTINGS_WINDOW_SAVE_STATE_KEY)) { - gsSettings.setInt(SETTINGS_WINDOW_STATE_KEY, getWindow().getState()); + gsSettings.setInt(SETTINGS_WINDOW_STATE_KEY, cast(int)getWindow().getState()); } return false; }); @@ -1818,25 +1610,23 @@ public: foreach (sessionFilename; tilix.getGlobalOverrides().session) { try { if (!exists(sessionFilename)) { - string filename = buildPath(tilix.getGlobalOverrides().cwd, sessionFilename); - tracef("Trying filename %s", filename); - if (exists(filename)) { - sessionFilename = filename; - } else { - warningf("Session filename '%s' does not exist, ignoring", filename); - continue; - } + errorf("Session file not found: %s", sessionFilename); + continue; } loadSession(sessionFilename); - } catch (SessionCreationException e) { - errorf("Could not load session from file '%s', error occurred", sessionFilename); - error(e.msg); + } catch (Exception e) { + errorf("Error loading session %s: %s", sessionFilename, e.msg); } } - if (nb.getNPages() > 0) return; } - //Create an initial session using default session name and profile - createSession(gsSettings.getString(SETTINGS_SESSION_NAME_KEY), prfMgr.getDefaultProfile()); + + // If no sessions were loaded, create a default one + if (nb.getNPages() == 0) { + createSession(); + } + + // Ensure UI state is updated after initialization + updateUIState(); } void initialize(Session session) { @@ -1849,12 +1639,12 @@ public: } /** - * Activates the specified sessionUUID + * Activate the session with the given UUID */ bool activateSession(string sessionUUID) { for (int i = 0; i < nb.getNPages(); i++) { - Session session = getSession(i); - if (session.uuid == sessionUUID) { + Session session = cast(Session) nb.getNthPage(i); + if (session !is null && session.uuid == sessionUUID) { nb.setCurrentPage(i); return true; } @@ -1866,10 +1656,9 @@ public: * Focus the previous session */ void focusPreviousSession() { - if (nb.getCurrentPage() > 0) { - nb.prevPage(); - } else { - nb.setCurrentPage(nb.getNPages() - 1); + int currentPage = nb.getCurrentPage(); + if (currentPage > 0) { + nb.setCurrentPage(currentPage - 1); } } @@ -1877,19 +1666,18 @@ public: * Focus the next session */ void focusNextSession() { - if (nb.getCurrentPage() < nb.getNPages() - 1) { - nb.nextPage(); - } else { - nb.setCurrentPage(0); + int currentPage = nb.getCurrentPage(); + if (currentPage < nb.getNPages() - 1) { + nb.setCurrentPage(currentPage + 1); } } /** - * Activates the specified terminal + * Activate a terminal by session and terminal UUID */ bool activateTerminal(string sessionUUID, string terminalUUID) { if (activateSession(sessionUUID)) { - return getCurrentSession().focusTerminal(terminalUUID); + return getCurrentSession().activateTerminal(terminalUUID); } return false; } @@ -1897,9 +1685,8 @@ public: bool activateTerminal(string terminalUUID) { for (int i = 0; i < nb.getNPages(); i++) { Session session = cast(Session) nb.getNthPage(i); - Widget result = session.findWidgetForUUID(terminalUUID); - if (result !is null) { - activateTerminal(session.uuid, terminalUUID); + if (session !is null && session.activateTerminal(terminalUUID)) { + nb.setCurrentPage(i); return true; } } @@ -1916,87 +1703,83 @@ public: string getActiveTerminalUUID() { ITerminal terminal = getActiveTerminal(); - if (terminal !is null) return terminal.uuid; - return null; + return terminal !is null ? terminal.uuid : ""; } /** - * Finds the widget matching a specific UUID, typically - * a Session or Terminal + * Find a widget (session or terminal) by UUID */ Widget findWidgetForUUID(string uuid) { for (int i = 0; i < nb.getNPages(); i++) { Session session = cast(Session) nb.getNthPage(i); - if (session.uuid == uuid) - return session; - trace("Searching session"); - Widget result = session.findWidgetForUUID(uuid); - if (result !is null) - return result; + if (session !is null) { + if (session.uuid == uuid) { + return session; + } + Widget terminal = session.findWidgetForUUID(uuid); + if (terminal !is null) { + return terminal; + } + } } return null; } /** - * Creates a new session and prompts the user for session properties + * Create a new session with default settings */ void createSession() { - // Hide the sidebar if it is open - if (!useTabs && sb.getRevealChild()) { - saViewSideBar.activate(null); - } - + string profileUUID; string workingDir; - string profileUUID = prfMgr.getDefaultProfile(); - - // Inherit current session directory unless overrides exist, fix #343 - if (tilix.getGlobalOverrides().cwd.length ==0 && tilix.getGlobalOverrides().workingDir.length == 0) { - ITerminal terminal = getActiveTerminal(); - if (terminal !is null) { - workingDir = terminal.currentLocalDirectory; - profileUUID = terminal.defaultProfileUUID; + CommandParameters params = tilix.getGlobalOverrides(); + + // Get profile from command line or default + if (params.profileName.length > 0) { + ProfileInfo profile = prfMgr.getProfileByName(params.profileName); + if (profile.uuid.length > 0) { + profileUUID = profile.uuid; } } - if (gsSettings.getBoolean(SETTINGS_PROMPT_ON_NEW_SESSION_KEY)) { - SessionProperties sp = new SessionProperties(this, gsSettings.getString(SETTINGS_SESSION_NAME_KEY), profileUUID); - scope (exit) { - sp.destroy(); - } - sp.showAll(); - if (sp.run() == ResponseType.OK) { - createSession(sp.name, sp.profileUUID, workingDir); - } - } else { - createSession(gsSettings.getString(SETTINGS_SESSION_NAME_KEY), profileUUID, workingDir); + if (profileUUID.length == 0) { + profileUUID = prfMgr.getDefaultProfile(); } + + // Get working directory + if (params.workingDir.length > 0) { + workingDir = params.workingDir; + } + + string sessionName = format(_("Session %d"), nb.getNPages() + 1); + createNewSession(sessionName, profileUUID, workingDir); } /** - * Information about any running processes in the window. + * Get process information for all sessions */ ProcessInformation getProcessInformation() { - ProcessInformation result = ProcessInformation(ProcessInfoSource.WINDOW, getTitle(), "", []); - for(int i=0; i 0) { - result.children ~= sessionInfo; - } + ProcessInformation result; + result.source = ProcessInfoSource.WINDOW; + result.name = getDisplayTitle(); + result.uuid = uuid; + + foreach (session; getSessions()) { + ProcessInformation pi = session.getProcessInformation(); + if (pi.children.length > 0) { + result.children ~= pi; } } return result; } /** - * Unique and immutable session ID + * Returns the UUID of this window */ @property string uuid() { return _windowUUID; } /** - * Invaidates background image cache and redraws + * Invalidate the cached background image */ void updateBackgroundImage() { if (isBGImage !is null) { @@ -2014,12 +1797,12 @@ public: * The image surface is cached between invocations to improve draw * performance as per #340. */ - ImageSurface getBackgroundImage(Widget widget) { + Surface getBackgroundImage(Widget widget) { if (isBGImage !is null) { return isBGImage; } - ImageSurface surface = tilix.getBackgroundImage(); + Surface surface = tilix.getBackgroundImage(); if (surface is null) { if (isBGImage !is null) { isBGImage.destroy(); @@ -2045,7 +1828,7 @@ public: break; } int scale = gsSettings.getEnum(SETTINGS_BACKGROUND_IMAGE_SCALE_KEY); - isBGImage = renderImage(surface, widget.getAllocatedWidth(), widget.getAllocatedHeight(), mode, true, cast(cairo_filter_t) scale); + isBGImage = renderImage(surface, widget.getAllocatedWidth(), widget.getAllocatedHeight(), mode, true, cast(Filter) scale); return isBGImage; } @@ -2067,7 +1850,7 @@ public: */ override void hide() { if (isQuake()) { - if (getWindow() !is null && ((getWindow().getState() & GdkWindowState.FULLSCREEN) == GdkWindowState.FULLSCREEN)) { + if (getWindow() !is null && ((getWindow().getState() & WindowState.Fullscreen) == WindowState.Fullscreen)) { unfullscreen(); wasFullscreen = true; } else { @@ -2118,7 +1901,7 @@ private: public: this(PositionType position, string text, Session session) { - super( (position==PositionType.LEFT || PositionType.RIGHT)?Orientation.VERTICAL:Orientation.HORIZONTAL , 5); + super((position == PositionType.Left || position == PositionType.Right) ? Orientation.Vertical : Orientation.Horizontal, 5); this.session = session; @@ -2132,7 +1915,7 @@ public: evNotifications.getStyleContext().addClass("tilix-notification-count"); afNotifications = new AspectFrame(null, 0.5, 0.5, 1.0, false); - afNotifications.setShadowType(ShadowType.NONE); + afNotifications.setShadowType(ShadowType.None); afNotifications.add(evNotifications); add(afNotifications); @@ -2140,16 +1923,14 @@ public: stTitle = new Stack(); lblText = new Label(text); - lblText.setEllipsize(PangoEllipsizeMode.START); + lblText.setEllipsize(EllipsizeMode.Start); lblText.setWidthChars(10); updatePositionType(position); - - // double clicking the EventBox will hide the EventBox and show the lblEditBox lblBox = new EventBox(); lblBox.add(lblText); - lblBox.addOnButtonPress(delegate(Event event, Widget w) { - if (event.getEventType() == EventType.DOUBLE_BUTTON_PRESS && event.button.button == MouseButton.PRIMARY) { + lblBox.connectButtonPressEvent(delegate(EventButton event) { + if (event.type == EventType._2buttonPress && event.button == 1) { lblEditBox.setText(session.name()); stTitle.setVisibleChildName(PAGE_EDIT); lblEditBox.grabFocus(); @@ -2159,35 +1940,31 @@ public: }); stTitle.addNamed(lblBox, PAGE_LABEL); - // when done editing the Entry, hide the Entry and show the lblBox again lblEditBox = new Entry(); lblEditBox.setHexpand(true); - lblEditBox.addOnFocusOut(delegate(Event event, Widget w) { + lblEditBox.connectFocusOutEvent(delegate(EventFocus event, Widget w) { string text = lblEditBox.getText().strip(); if (text.length == 0) - return GDK_EVENT_PROPAGATE; + return false; session.name(text); stTitle.setVisibleChildName(PAGE_LABEL); - return GDK_EVENT_PROPAGATE; + return false; }); - lblEditBox.addOnKeyPress(delegate (Event event, Widget widget) { - uint keyval; - if (event.getKeyval(keyval)) { - switch (keyval) { - case GdkKeysyms.GDK_Escape: - stTitle.setVisibleChildName(PAGE_LABEL); - return true; - case GdkKeysyms.GDK_Return: - session.name(text); - stTitle.setVisibleChildName(PAGE_LABEL); - return true; - default: - } + lblEditBox.connectKeyPressEvent(delegate(EventKey event) { + switch (event.keyval) { + case GdkKeysyms.GDK_Escape: + stTitle.setVisibleChildName(PAGE_LABEL); + return true; + case GdkKeysyms.GDK_Return: + session.name(lblEditBox.getText()); + stTitle.setVisibleChildName(PAGE_LABEL); + return true; + default: } return false; }); - if (Version.checkVersion(3, 16, 0).length == 0) { + if (checkVersion(3, 16, 0) is null) { stTitle.addNamed(createTitleEditHelper(lblEditBox, TitleEditScope.SESSION), PAGE_EDIT); } else { stTitle.addNamed(lblEditBox, PAGE_EDIT); @@ -2195,19 +1972,19 @@ public: add(stTitle); - imgNewOutput = new Image("view-list-symbolic", IconSize.MENU); + imgNewOutput = Image.newFromIconName("view-list-symbolic", IconSize.Menu); imgNewOutput.setNoShowAll(true); imgNewOutput.setTooltipText(_("New output displayed")); add(imgNewOutput); - button = new Button("window-close-symbolic", IconSize.MENU); + button = Button.newFromIconName("window-close-symbolic", IconSize.Menu); button.getStyleContext().addClass("tilix-small-button"); - button.setRelief(ReliefStyle.NONE); + button.setRelief(ReliefStyle.None); button.setFocusOnClick(false); button.setTooltipText(_("Close session")); - button.addOnClicked(&closeClicked); + button.connectClicked(&closeClicked); add(button); @@ -2253,20 +2030,19 @@ public: } void updatePositionType(PositionType position) { - if (position == PositionType.LEFT || position == PositionType.RIGHT) { - setOrientation(Orientation.VERTICAL); - lblText.setAngle(position==PositionType.LEFT?90:270); + if (position == PositionType.Left || position == PositionType.Right) { + setOrientation(Orientation.Vertical); + lblText.setAngle(position == PositionType.Left ? 90 : 270); lblText.setHexpand(false); lblText.setVexpand(true); } else { - setOrientation(Orientation.HORIZONTAL); + setOrientation(Orientation.Horizontal); lblText.setAngle(0); lblText.setHexpand(true); lblText.setVexpand(false); } } - void clearNotifications() { afNotifications.hide(); } @@ -2275,4 +2051,4 @@ public: * Event triggered when user clicks the close button */ GenericEvent!(Session) onCloseClicked; -} +} \ No newline at end of file diff --git a/source/gx/tilix/bookmark/bmchooser.d b/source/gx/tilix/bookmark/bmchooser.d index 8b9e772c8..2c70361c0 100644 --- a/source/gx/tilix/bookmark/bmchooser.d +++ b/source/gx/tilix/bookmark/bmchooser.d @@ -4,18 +4,29 @@ */ module gx.tilix.bookmark.bmchooser; -import gdk.Event; -import gdk.Keysyms; +import gdk.event; +// GID does not provide gdk.keysyms, define required key constants locally +private enum GdkKeysyms { + GDK_Escape = 0xff1b, + GDK_Return = 0xff0d, +} + +import gdk.event_key : EventKey; -import gio.Settings: GSettings = Settings; +import gio.settings: GSettings = Settings; +import gio.types : SettingsBindFlags; -import gtk.Box; -import gtk.CheckButton; -import gtk.Dialog; -import gtk.ScrolledWindow; -import gtk.SearchEntry; -import gtk.Widget; -import gtk.Window; +import gtk.box; +import gtk.check_button : CheckButton; +import gtk.dialog; +import gtk.scrolled_window; +import gtk.search_entry : SearchEntry; +import gtk.tree_path : TreePath; +import gtk.tree_view : TreeView; +import gtk.tree_view_column : TreeViewColumn; +import gtk.types : DialogFlags, Orientation, PolicyType, ResponseType, SelectionMode, ShadowType; +import gtk.widget; +import gtk.window; import gx.gtk.util; @@ -46,38 +57,39 @@ private: tv = new BMTreeView(true, mode == BMSelectionMode.FOLDER); tv.setActivateOnSingleClick(false); tv.setHeadersVisible(false); - tv.getSelection().setMode(SelectionMode.BROWSE); - tv.addOnCursorChanged(delegate(TreeView) { + tv.getSelection().setMode(SelectionMode.Browse); + tv.connectCursorChanged(delegate(TreeView v) { updateUI(); }); - tv.addOnRowActivated(delegate(TreePath, TreeViewColumn, TreeView) { - response(ResponseType.OK); + tv.connectRowActivated(delegate(TreePath p, TreeViewColumn c, TreeView v) { + response(ResponseType.Ok); }); - tv.addOnKeyPress(&checkKeyPress); + tv.connectKeyPressEvent(&checkKeyPress); - ScrolledWindow sw = new ScrolledWindow(tv); - sw.setShadowType(ShadowType.ETCHED_IN); - sw.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + ScrolledWindow sw = new ScrolledWindow(null, null); + sw.add(tv); + sw.setShadowType(ShadowType.EtchedIn); + sw.setPolicy(PolicyType.Never, PolicyType.Automatic); sw.setHexpand(true); sw.setVexpand(true); sw.setSizeRequest(-1, 200); SearchEntry se = new SearchEntry(); - se.addOnSearchChanged(delegate(SearchEntry) { + se.connectSearchChanged(delegate(SearchEntry entry) { tv.filterText = se.getText(); updateUI(); }); - se.addOnKeyPress(&checkKeyPress); + se.connectKeyPressEvent(&checkKeyPress); - Box box = new Box(Orientation.VERTICAL, 6); + Box box = new Box(Orientation.Vertical, 6); setAllMargins(box, 18); box.add(se); box.add(sw); if (mode != BMSelectionMode.FOLDER) { gsSettings = new GSettings(SETTINGS_ID); - CheckButton cbIncludeEnter = new CheckButton(_("Include return character with bookmark")); - gsSettings.bind(SETTINGS_BOOKMARK_INCLUDE_RETURN_KEY, cbIncludeEnter, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbIncludeEnter = CheckButton.newWithLabel(_("Include return character with bookmark")); + gsSettings.bind(SETTINGS_BOOKMARK_INCLUDE_RETURN_KEY, cbIncludeEnter, "active", SettingsBindFlags.Default); box.add(cbIncludeEnter); } @@ -85,7 +97,7 @@ private: } void updateUI() { - setResponseSensitive(ResponseType.OK, isSelectEnabled()); + setResponseSensitive(ResponseType.Ok, isSelectEnabled()); } bool isSelectEnabled() { @@ -104,28 +116,32 @@ private: return enabled; } - bool checkKeyPress(Event event, Widget w) { - uint keyval; - if (event.getKeyval(keyval)) { - if (keyval == GdkKeysyms.GDK_Escape) { - response = ResponseType.CANCEL; + bool checkKeyPress(EventKey event, Widget w) { + if (event is null) return false; + uint keyval = event.keyval; + if (keyval == GdkKeysyms.GDK_Escape) { + response(ResponseType.Cancel); + return true; + } + if (keyval == GdkKeysyms.GDK_Return) { + if (isSelectEnabled()) { + response(ResponseType.Ok); return true; } - if (keyval == GdkKeysyms.GDK_Return) { - if (isSelectEnabled()) { - response = ResponseType.OK; - return true; - } - } } return false; } public: this(Window parent, BMSelectionMode mode) { + super(); string title = mode == BMSelectionMode.FOLDER? _("Select Folder"):_("Select Bookmark"); - super(title, parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [_("OK"), _("Cancel")], [GtkResponseType.OK, GtkResponseType.CANCEL]); - setDefaultResponse(GtkResponseType.OK); + setTitle(title); + setTransientFor(parent); + setModal(true); + addButton(_("Cancel"), ResponseType.Cancel); + addButton(_("OK"), ResponseType.Ok); + setDefaultResponse(ResponseType.Ok); this.mode = mode; createUI(); updateUI(); diff --git a/source/gx/tilix/bookmark/bmeditor.d b/source/gx/tilix/bookmark/bmeditor.d index 7d9deca8f..5bb732225 100644 --- a/source/gx/tilix/bookmark/bmeditor.d +++ b/source/gx/tilix/bookmark/bmeditor.d @@ -9,27 +9,30 @@ import std.experimental.logger; import std.signals; import std.string; import std.traits; - -import glib.Util; - -import gobject.ObjectG; -import gobject.ParamSpec; - -import gtk.Box; -import gtk.Button; -import gtk.ComboBox; -import gtk.Dialog; -import gtk.Entry; -import gtk.FileChooserButton; -import gtk.Grid; -import gtk.HeaderBar; -import gtk.Label; -import gtk.Separator; -import gtk.SpinButton; -import gtk.Stack; -import gtk.StackSwitcher; -import gtk.Widget; -import gtk.Window; +import std.typecons : Yes; + +import glib.global : getHomeDir; + +import gobject.object : ObjectWrap; +import gobject.param_spec; + +import gtk.box; +import gtk.button; +import gtk.combo_box; +import gtk.dialog; +import gtk.editable : Editable; +import gtk.entry; +import gtk.file_chooser_button; +import gtk.grid; +import gtk.header_bar; +import gtk.label; +import gtk.separator; +import gtk.types : Align, DialogFlags, FileChooserAction, IconSize, Orientation, ResponseType; +import gtk.spin_button; +import gtk.stack; +import gtk.stack_switcher; +import gtk.widget; +import gtk.window; import gx.gtk.util; import gx.i18n.l10n; @@ -58,11 +61,11 @@ private: FolderBookmark _folder; void createUI(Bookmark bm, bool folderPicker) { - Box bContent = new Box(Orientation.VERTICAL, 6); + Box bContent = new Box(Orientation.Vertical, 6); setAllMargins(bContent, 18); if (folderPicker) { - Box bPicker = new Box(Orientation.HORIZONTAL, 0); + Box bPicker = new Box(Orientation.Horizontal, 0); bPicker.getStyleContext().addClass("linked"); eFolder = new Entry(); eFolder.setPlaceholderText(_("Select Folder")); @@ -70,21 +73,20 @@ private: eFolder.setHexpand(true); bPicker.add(eFolder); - Button btnFolderPicker = new Button("folder-symbolic", IconSize.BUTTON); + Button btnFolderPicker = Button.newFromIconName("folder-symbolic", IconSize.Button); btnFolderPicker.setTooltipText(_("Select folder")); - btnFolderPicker.addOnClicked(delegate(Button) { + btnFolderPicker.connectClicked(delegate(Button btn) { BookmarkChooser bc = new BookmarkChooser(this, BMSelectionMode.FOLDER); scope(exit) {bc.destroy();} bc.showAll(); - if (bc.run() == ResponseType.OK) { + if (bc.run() == ResponseType.Ok) { folder = cast(FolderBookmark) bc.bookmark; } }); bPicker.add(btnFolderPicker); - - Button btnClearFolder = new Button("edit-clear-symbolic", IconSize.BUTTON); + Button btnClearFolder = Button.newFromIconName("edit-clear-symbolic", IconSize.Button); btnClearFolder.setTooltipText(_("Clear folder")); - btnClearFolder.addOnClicked(delegate(Button) { + btnClearFolder.connectClicked(delegate(Button btn) { _folder = null; eFolder.setText(""); }); @@ -93,13 +95,13 @@ private: } stEditors = new Stack(); - stEditors.addOnNotify(delegate(ParamSpec, ObjectG) { + stEditors.connectNotify("visible-child", delegate(ParamSpec ps, ObjectWrap obj) { updateUI(); BaseEditor be = cast(BaseEditor)stEditors.getVisibleChild(); if (be !is null) { be.focusEditor(); } - },"visible-child", ConnectFlags.AFTER); + }, Yes.After); // Adding a new bookmark or editing one? if (mode == BookmarkEditorMode.EDIT) { @@ -134,26 +136,30 @@ private: void validateChanged(BaseEditor be, bool valid) { if (be == getEditor()) { - setResponseSensitive(ResponseType.OK, valid); + setResponseSensitive(ResponseType.Ok, valid); } } void updateUI() { if (getEditor() !is null) { - setResponseSensitive(ResponseType.OK, getEditor().validate()); + setResponseSensitive(ResponseType.Ok, getEditor().validate()); } } public: this(Window parent, BookmarkEditorMode mode, Bookmark bm = null, bool folderPicker = false) { + super(); string title = (mode == BookmarkEditorMode.ADD)? _("Add Bookmark"):_("Edit Bookmark"); - super(title, parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [_("OK"), _("Cancel")], [GtkResponseType.OK, GtkResponseType.CANCEL]); + setTitle(title); setTransientFor(parent); - setDefaultResponse(GtkResponseType.OK); + setModal(true); + addButton(_("Cancel"), ResponseType.Cancel); + addButton(_("OK"), ResponseType.Ok); + setDefaultResponse(ResponseType.Ok); this.mode = mode; createUI(bm, folderPicker); - this.addOnShow(delegate(Widget) { + this.connectShow(delegate(Widget w) { BaseEditor be = cast(BaseEditor)stEditors.getVisibleChild(); be.focusEditor(); }); @@ -217,7 +223,7 @@ protected: Label createLabel(string text) { Label result = new Label(text); - result.setHalign(GtkAlign.END); + result.setHalign(Align.End); return result; } @@ -232,7 +238,7 @@ public: eName = new Entry(); eName.setHexpand(true); - eName.addOnChanged(delegate(EditableIF) { + eName.connectChanged(delegate(Editable e) { onValidChanged.emit(this, validate); }); attach(eName, 1, row, 1, 1); @@ -291,9 +297,9 @@ public: attach(createLabel(_("Path")), 0, row, 1, 1); - fcbPath = new FileChooserButton(_("Select Path"), FileChooserAction.SELECT_FOLDER); + fcbPath = new FileChooserButton(_("Select Path"), FileChooserAction.SelectFolder); fcbPath.setHexpand(true); - fcbPath.setFilename(Util.getHomeDir()); + fcbPath.setFilename(getHomeDir()); attach(fcbPath, 1, row, 1, 1); row++; @@ -333,7 +339,7 @@ public: attach(createLabel(_("Command")), 0, row, 1, 1); eCommand = new Entry(); - eCommand.addOnChanged(delegate(EditableIF) { + eCommand.connectChanged(delegate(Editable e) { onValidChanged.emit(this, validate); }); eCommand.setHexpand(true); @@ -388,7 +394,7 @@ public: cbProtocol = createNameValueCombo(protocols); cbProtocol.setActiveId(to!string(ProtocolType.SSH)); - cbProtocol.addOnChanged(delegate(ComboBox) { + cbProtocol.connectChanged(delegate(ComboBox cb) { eCommand.setSensitive(cbProtocol.getActiveId() == to!string(ProtocolType.SSH)); }); attach(cbProtocol, 1, row, 1, 1); @@ -396,15 +402,15 @@ public: // Host and Port attach(createLabel(_("Host")), 0, row, 1, 1); - Box bHost = new Box(Orientation.HORIZONTAL, 6); + Box bHost = new Box(Orientation.Horizontal, 6); eHost = new Entry(); - eHost.addOnChanged(delegate(EditableIF) { + eHost.connectChanged(delegate(Editable e) { onValidChanged.emit(this, validate); }); eHost.setHexpand(true); bHost.add(eHost); bHost.add(new Label(":")); - sPort = new SpinButton(0, 65535, 1); + sPort = SpinButton.newWithRange(0, 65535, 1); sPort.setValue(0); bHost.add(sPort); attach(bHost, 1, row, 1, 1); diff --git a/source/gx/tilix/bookmark/bmtreeview.d b/source/gx/tilix/bookmark/bmtreeview.d index 56c8b4a3f..4fef0c1f2 100644 --- a/source/gx/tilix/bookmark/bmtreeview.d +++ b/source/gx/tilix/bookmark/bmtreeview.d @@ -10,25 +10,28 @@ import std.string; import std.traits; import std.typecons : No; -import gdk.Atom; -import gdk.DragContext; -import gdk.Pixbuf; - -import gobject.Value; - -import gtk.CellRendererPixbuf; -import gtk.CellRendererText; -import gtk.SelectionData; -import gtk.TargetEntry; -import gtk.TreeViewColumn; -import gtk.TreeIter; -import gtk.TreeModel; -import gtk.TreeModelIF; -import gtk.TreeModelFilter; -import gtk.TreePath; -import gtk.TreeStore; -import gtk.TreeView; -import gtk.Widget; +import gdk.atom : Atom; +import gdk.drag_context; +import gdk.types : DragAction, ModifierType; +import gdkpixbuf.pixbuf; + +import gobject.value; + +import gx.gtk.util : GTypes; + +import gtk.cell_renderer_pixbuf : CellRendererPixbuf; +import gtk.cell_renderer_text : CellRendererText; +import gtk.selection_data; +import gtk.target_entry; +import gtk.tree_view_column : TreeViewColumn; +import gtk.tree_iter; +import gtk.tree_model; +import gtk.tree_model_filter; +import gtk.tree_path; +import gtk.tree_store; +import gtk.tree_view; +import gtk.types : TargetFlags, TreeViewDropPosition; +import gtk.widget; import gx.i18n.l10n; @@ -42,7 +45,7 @@ enum Columns : uint { } TreeStore createBMTreeModel(Pixbuf[] icons, bool foldersOnly) { - TreeStore ts = new TreeStore([Pixbuf.getType(), GType.STRING, GType.STRING, GType.BOOLEAN]); + TreeStore ts = TreeStore.new_([Pixbuf._getGType(), GTypes.STRING, GTypes.STRING, GTypes.BOOLEAN]); loadBookmarks(ts, null, bmMgr.root, foldersOnly, icons); return ts; } @@ -67,22 +70,52 @@ private: void createColumns() { CellRendererPixbuf crp = new CellRendererPixbuf(); crp.setProperty("stock-size", 16); - TreeViewColumn column = new TreeViewColumn(_("Icon"), crp, "pixbuf", Columns.ICON); + TreeViewColumn column = new TreeViewColumn(); + column.setTitle(_("Icon")); + column.packStart(crp, true); + column.addAttribute(crp, "pixbuf", cast(int)Columns.ICON); appendColumn(column); - column = new TreeViewColumn(_("Name"), new CellRendererText(), "text", Columns.NAME); + CellRendererText crtName = new CellRendererText(); + column = new TreeViewColumn(); + column.setTitle(_("Name")); + column.packStart(crtName, true); + column.addAttribute(crtName, "text", cast(int)Columns.NAME); column.setExpand(true); appendColumn(column); - column = new TreeViewColumn("UUID", new CellRendererText(), "text", Columns.UUID); + CellRendererText crtUuid = new CellRendererText(); + column = new TreeViewColumn(); + column.setTitle("UUID"); + column.packStart(crtUuid, true); + column.addAttribute(crtUuid, "text", cast(int)Columns.UUID); column.setVisible(false); appendColumn(column); - column = new TreeViewColumn("Filter", new CellRendererText(), "text", Columns.FILTER); + CellRendererText crtFilter = new CellRendererText(); + column = new TreeViewColumn(); + column.setTitle("Filter"); + column.packStart(crtFilter, true); + column.addAttribute(crtFilter, "text", cast(int)Columns.FILTER); column.setVisible(false); appendColumn(column); } + TreeIter getSelectedIter() { + TreeModel model; + TreeIter iter; + if (getSelection().getSelected(model, iter)) { + return iter; + } + return null; + } + + string getValueString(TreeModel model, TreeIter iter, int column) { + Value val; + model.getValue(iter, column, val); + return val.getString(); + } + FolderBookmark getParentBookmark(Bookmark bm, out TreeIter parent) { parent = getSelectedIter(); if (parent is null) return null; @@ -92,7 +125,7 @@ private: return bmMgr.root; } } - return cast(FolderBookmark) bmMgr.get(getModel().getValueString(parent, Columns.UUID)); + return cast(FolderBookmark) bmMgr.get(getValueString(getModel(), parent, cast(int)Columns.UUID)); } /** @@ -100,20 +133,19 @@ private: * of the node that should be focused. */ void updateFilter() { - void checkFilter(TreeIter iter) { - string name = ts.getValueString(iter, Columns.NAME); + string name = getValueString(ts, iter, cast(int)Columns.NAME); bool visible = filterText.length == 0 || name.indexOf(filterText, No.caseSensitive) >= 0; - ts.setValue(iter, Columns.FILTER, visible); + ts.setValue(iter, cast(int)Columns.FILTER, new Value(visible)); if (visible) { TreeIter parent = iter; - Value value = new Value(); + Value value; // Walk up the parent hierarchy and set it's visibility to true while (ts.iterParent(parent, parent)) { // has parent visibility already been set? - value = ts.getValue(parent, Columns.FILTER, value); + ts.getValue(parent, cast(int)Columns.FILTER, value); if (value.getBoolean()) break; - ts.setValue(parent, Columns.FILTER, true); + ts.setValue(parent, cast(int)Columns.FILTER, new Value(true)); //if (!ts.iterParent(parent, parent)) break; } } @@ -138,7 +170,7 @@ private: void selectFirstFilteredLeaf() { bool focusLeaf(TreeIter iter) { - string uuid = filter.getValueString(iter, Columns.UUID); + string uuid = getValueString(filter, iter, cast(int)Columns.UUID); FolderBookmark bm = cast(FolderBookmark) bmMgr.get(uuid); if (bm is null) { getSelection().selectIter(iter); @@ -171,9 +203,9 @@ private: TreeIter iter = getSelectedIter(); if (iter !is null) { //string uuid = ts.getValueString(iter, Columns.UUID); - string path = iter.getTreePath().toString(); - char[] buffer = (path ~ '\0').dup; - data.set(intern(BOOKMARK_DND, false), 8, buffer); + string path = ts.getPath(iter).toString(); + ubyte[] buffer = cast(ubyte[])(path ~ '\0').dup; + data.set(Atom.intern(BOOKMARK_DND, false), 8, buffer); } } @@ -186,26 +218,26 @@ private: TreeIter target = new TreeIter(); ts.getIter(target, pathTarget); - string dataPath = to!string(data.getDataWithLength()[0 .. $ - 1]); + string dataPath = cast(string)(data.getData()[0 .. $ - 1]); tracef("Data received %s", dataPath); - TreePath pathSource = new TreePath(dataPath); + TreePath pathSource = TreePath.newFromString(dataPath); TreeIter source = new TreeIter(); ts.getIter(source, pathSource); //Move bookmark first - Bookmark bmTarget = bmMgr.get(ts.getValueString(target, Columns.UUID)); - Bookmark bmSource = bmMgr.get(ts.getValueString(source, Columns.UUID)); + Bookmark bmTarget = bmMgr.get(getValueString(ts, target, cast(int)Columns.UUID)); + Bookmark bmSource = bmMgr.get(getValueString(ts, source, cast(int)Columns.UUID)); try { switch (tvdp) { - case TreeViewDropPosition.BEFORE: + case TreeViewDropPosition.Before: bmMgr.moveBefore(bmTarget, bmSource); break; - case TreeViewDropPosition.AFTER: + case TreeViewDropPosition.After: bmMgr.moveAfter(bmTarget, bmSource); break; - case TreeViewDropPosition.INTO_OR_BEFORE: + case TreeViewDropPosition.IntoOrBefore: .. - case TreeViewDropPosition.INTO_OR_AFTER: + case TreeViewDropPosition.IntoOrAfter: FolderBookmark fb = cast(FolderBookmark) bmTarget; if (fb is null) { error("Unexpected, not a folder bookmark, bookmark not moved"); @@ -226,41 +258,43 @@ private: TreeIter iter; final switch (tvdp) { - case TreeViewDropPosition.BEFORE: + case TreeViewDropPosition.Before: TreeIter iterParent; if (!ts.iterParent(iterParent, target)) { iterParent = null; } ts.insertBefore(iter, iterParent, target); break; - case TreeViewDropPosition.AFTER: + case TreeViewDropPosition.After: TreeIter iterParent; if (!ts.iterParent(iterParent, target)) { iterParent = null; } ts.insertAfter(iter, iterParent, target); break; - case TreeViewDropPosition.INTO_OR_BEFORE: - iter = ts.append(target); + case TreeViewDropPosition.IntoOrBefore: + ts.append(iter, target); break; - case TreeViewDropPosition.INTO_OR_AFTER: - iter = ts.append(target); + case TreeViewDropPosition.IntoOrAfter: + ts.append(iter, target); break; } foreach(column; EnumMembers!Columns) { - ts.setValue(iter, column, ts.getValue(source, column)); + Value val; + ts.getValue(source, cast(int)column, val); + ts.setValue(iter, cast(int)column, val); } ts.remove(source); } void setupDragAndDrop() { - TargetEntry bmEntry = new TargetEntry(BOOKMARK_DND, TargetFlags.SAME_WIDGET, DropTargets.BOOKMARK); + TargetEntry bmEntry = new TargetEntry(BOOKMARK_DND, TargetFlags.SameWidget, DropTargets.BOOKMARK); TargetEntry[] targets = [bmEntry]; - enableModelDragDest(targets, DragAction.MOVE); - enableModelDragSource(ModifierType.BUTTON1_MASK, targets, DragAction.MOVE); - addOnDragDataGet(&onDragDataGet); - addOnDragDataReceived(&onDragDataReceived); + enableModelDragDest(targets, DragAction.Move); + enableModelDragSource(ModifierType.Button1Mask, targets, DragAction.Move); + connectDragDataGet(&onDragDataGet); + connectDragDataReceived(&onDragDataReceived); } public: @@ -270,8 +304,8 @@ public: ts = createBMTreeModel(icons, foldersOnly); if (enableFilter) { - filter = new TreeModelFilter(ts, null); - filter.setVisibleColumn(Columns.FILTER); + filter = cast(TreeModelFilter) ts.filterNew(null); + filter.setVisibleColumn(cast(int)Columns.FILTER); setModel(filter); } else { setModel(ts); @@ -285,7 +319,7 @@ public: Bookmark getSelectedBookmark() { TreeIter selected = getSelectedIter(); if (selected is null) return null; - return bmMgr.get(getModel().getValueString(selected, Columns.UUID)); + return bmMgr.get(getValueString(getModel(), selected, cast(int)Columns.UUID)); } /** @@ -310,7 +344,7 @@ public: TreeIter iter = addBookmarktoParent(ts, parent, bm, icons); ignoreOperationFlag = false; if (parent !is null) { - expandRow(parent, ts, false); + expandRow(ts.getPath(parent), false); } getSelection().selectIter(iter); return fbm; @@ -335,8 +369,8 @@ public: */ void updateBookmark(Bookmark bm) { TreeIter selected = getSelectedIter(); - if (selected is null || ts.getValueString(selected, Columns.UUID) != bm.uuid) return; - ts.setValue(selected, Columns.NAME, bm.name); + if (selected is null || getValueString(ts, selected, cast(int)Columns.UUID) != bm.uuid) return; + ts.setValue(selected, cast(int)Columns.NAME, new Value(bm.name)); } @property string filterText() { @@ -376,10 +410,11 @@ void loadBookmarks(TreeStore ts, TreeIter current, FolderBookmark parent, bool f } TreeIter addBookmarktoParent(TreeStore ts, TreeIter parent, Bookmark bm, Pixbuf[] icons) { - TreeIter result = ts.createIter(parent); - ts.setValue(result, Columns.ICON, icons[cast(uint)bm.type()]); - ts.setValue(result, Columns.NAME, bm.name); - ts.setValue(result, Columns.UUID, bm.uuid); - ts.setValue(result, Columns.FILTER, true); + TreeIter result; + ts.append(result, parent); + ts.setValue(result, cast(int)Columns.ICON, new Value(icons[cast(uint)bm.type()])); + ts.setValue(result, cast(int)Columns.NAME, new Value(bm.name)); + ts.setValue(result, cast(int)Columns.UUID, new Value(bm.uuid)); + ts.setValue(result, cast(int)Columns.FILTER, new Value(true)); return result; } \ No newline at end of file diff --git a/source/gx/tilix/bookmark/manager.d b/source/gx/tilix/bookmark/manager.d index 7ea1a108f..34dfe6750 100644 --- a/source/gx/tilix/bookmark/manager.d +++ b/source/gx/tilix/bookmark/manager.d @@ -13,16 +13,17 @@ import std.json; import std.path; import std.uuid; -import gdk.Pixbuf; -import gdk.RGBA; -import gdk.Screen; +import gdkpixbuf.pixbuf; +import gdk.rgba; +import gdk.screen; -import glib.Util; +import glib.global : getUserConfigDir; -import gtk.IconInfo; -import gtk.IconTheme; -import gtk.StyleContext; -import gtk.Widget; +import gtk.icon_info; +import gtk.icon_theme; +import gtk.types : IconLookupFlags; +import gtk.style_context; +import gtk.widget; import gx.i18n.l10n; @@ -595,7 +596,7 @@ public: } void save() { - string path = buildPath(Util.getUserConfigDir(), APPLICATION_CONFIG_FOLDER); + string path = buildPath(getUserConfigDir(), APPLICATION_CONFIG_FOLDER); if (!exists(path)) { mkdirRecurse(path); } @@ -605,7 +606,7 @@ public: } void load() { - string filename = buildPath(Util.getUserConfigDir(), APPLICATION_CONFIG_FOLDER, BOOKMARK_FILE); + string filename = buildPath(getUserConfigDir(), APPLICATION_CONFIG_FOLDER, BOOKMARK_FILE); if (exists(filename)) { try { string json = readText(filename); @@ -654,7 +655,11 @@ Pixbuf[] getBookmarkIcons(Widget widget) { return [null, null, null, null]; } foreach(name; names) { - IconInfo iconInfo = iconTheme.lookupIcon(name, 16, IconLookupFlags.GENERIC_FALLBACK); + IconInfo iconInfo = iconTheme.lookupIcon(name, 16, IconLookupFlags.GenericFallback); + if (iconInfo is null) { + icons ~= null; + continue; + } bool wasSymbolic; icons ~= iconInfo.loadSymbolic(fg, null, null, null, wasSymbolic); } diff --git a/source/gx/tilix/closedialog.d b/source/gx/tilix/closedialog.d index bddb2489a..903f4ef2b 100644 --- a/source/gx/tilix/closedialog.d +++ b/source/gx/tilix/closedialog.d @@ -6,33 +6,44 @@ module gx.tilix.closedialog; import std.experimental.logger; import std.format; - -import gdkpixbuf.Pixbuf; - -import gdk.Event; -import gdk.Keysyms; - -import gio.Settings: GSettings = Settings; - -import gobject.Value; - -import gtk.Box; -import gtk.CellRendererPixbuf; -import gtk.CellRendererText; -import gtk.CheckButton; -import gtk.Dialog; -import gtk.IconInfo; -import gtk.IconTheme; -import gtk.Label; -import gtk.ScrolledWindow; -import gtk.TreeIter; -import gtk.TreeStore; -import gtk.TreeView; -import gtk.TreeViewColumn; -import gtk.Window; +import std.typecons : Yes; + +import gdkpixbuf.pixbuf : Pixbuf; + +import gdk.event : Event; +import gdk.event_key : EventKey; + +import gio.settings : GSettings = Settings; + +import gobject.c.types : GType; +import gobject.value : Value; + +import gtk.box : Box; +import gtk.cell_renderer_pixbuf : CellRendererPixbuf; +import gtk.cell_renderer_text : CellRendererText; +import gtk.check_button : CheckButton; +import gtk.dialog : Dialog; +import gtk.icon_info : IconInfo; +import gtk.icon_theme : IconTheme; +import gtk.label : Label; +import gtk.scrolled_window : ScrolledWindow; +import gtk.tree_iter : TreeIter; +import gtk.tree_store : TreeStore; +import gtk.tree_view : TreeView; +import gtk.tree_view_column : TreeViewColumn; +import gtk.types : Align, DialogFlags, ResponseType, IconLookupFlags, Orientation, PolicyType, ShadowType; +import pango.types : EllipsizeMode; +import gtk.widget : Widget; +import gtk.window : Window; + +// GID does not provide gdk.keysyms, so define the required key constants locally +private enum GdkKeysyms { + GDK_Escape = 0xff1b, + GDK_Return = 0xff0d, +} import gx.i18n.l10n; -import gx.gtk.util; +import gx.gtk.util : GTypes, setAllMargins; import gx.tilix.common; import gx.tilix.preferences; @@ -49,13 +60,13 @@ bool promptCanCloseProcesses(GSettings gsSettings, Window window, ProcessInforma scope(exit) { dialog.destroy();} dialog.showAll(); int result = dialog.run(); - if (result == ResponseType.OK && dialog.futureIgnore) { + if (result == ResponseType.Ok && dialog.futureIgnore) { gsSettings.setBoolean(SETTINGS_PROMPT_ON_CLOSE_PROCESS_KEY, false); } // Weird looking code, exists because of the way hotkeys get interpreted into results, it's // easier to check if the result is not OK - bool cancelClose = (result != ResponseType.OK); + bool cancelClose = (result != ResponseType.Ok); return !cancelClose; } @@ -88,51 +99,55 @@ private: warning("Could not load icon for 'utilities-terminal'"); } setAllMargins(getContentArea(), 18); - Box box = new Box(Orientation.VERTICAL, 6); + Box box = new Box(Orientation.Vertical, 6); Label lbl = new Label("There are processes still running as shown below, close anyway?"); - lbl.setHalign(GtkAlign.START); + lbl.setHalign(Align.Start); lbl.setMarginBottom(6); box.add(lbl); - ts = new TreeStore([GType.STRING, Pixbuf.getType(), GType.STRING]); + ts = TreeStore.new_([GTypes.STRING, Pixbuf._getGType(), GTypes.STRING]); loadProcesses(); - - tv = new TreeView(ts); - tv.addOnKeyRelease(delegate(Event event, Widget) { - uint keyval; - if (event.getKeyval(keyval)) { - switch (keyval) { - case GdkKeysyms.GDK_Escape: - response(GtkResponseType.CANCEL); - break; - case GdkKeysyms.GDK_Return: - response(GtkResponseType.OK); - break; - default: - } + tv = new TreeView(); + tv.setModel(ts); + tv.connectKeyReleaseEvent(delegate(EventKey event, Widget w) { + uint keyval = event.keyval; + switch (keyval) { + case GdkKeysyms.GDK_Escape: + response(ResponseType.Cancel); + break; + case GdkKeysyms.GDK_Return: + response(ResponseType.Ok); + break; + default: } return false; - }); tv.setHeadersVisible(false); CellRendererText crt = new CellRendererText(); - crt.setProperty("ellipsize", new Value(PangoEllipsizeMode.END)); + crt.setProperty("ellipsize", new Value(EllipsizeMode.End)); - TreeViewColumn column = new TreeViewColumn(_("Title"), crt, "text", COLUMNS.NAME); + TreeViewColumn column = new TreeViewColumn(); + column.setTitle(_("Title")); + column.packStart(crt, true); + column.addAttribute(crt, "text", cast(int)COLUMNS.NAME); column.setExpand(true); tv.appendColumn(column); CellRendererPixbuf crp = new CellRendererPixbuf(); crp.setProperty("stock-size", 16); - column = new TreeViewColumn(_("Icon"), crp, "pixbuf", COLUMNS.ICON); + column = new TreeViewColumn(); + column.setTitle(_("Icon")); + column.packStart(crp, true); + column.addAttribute(crp, "pixbuf", cast(int)COLUMNS.ICON); column.setExpand(true); tv.appendColumn(column); - ScrolledWindow sw = new ScrolledWindow(tv); - sw.setShadowType(ShadowType.ETCHED_IN); - sw.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + ScrolledWindow sw = new ScrolledWindow(null, null); + sw.add(tv); + sw.setShadowType(ShadowType.EtchedIn); + sw.setPolicy(PolicyType.Never, PolicyType.Automatic); sw.setHexpand(true); sw.setVexpand(true); sw.setSizeRequest(-1, 300); @@ -140,7 +155,7 @@ private: box.add(sw); tv.expandAll(); - cbIgnore = new CheckButton(_("Do not show this again")); + cbIgnore = CheckButton.newWithLabel(_("Do not show this again")); box.add(cbIgnore); getContentArea().add(box); @@ -161,22 +176,23 @@ private: } void loadProcess(TreeIter parent, ProcessInformation pi) { - TreeIter current = ts.createIter(parent); + TreeIter current; + ts.append(current, parent); if (pi.source == ProcessInfoSource.TERMINAL) { - ts.setValue(current, COLUMNS.ICON, pbTerminal); + ts.setValue(current, cast(int)COLUMNS.ICON, new Value(pbTerminal)); } switch (pi.source) { case ProcessInfoSource.WINDOW: - ts.setValue(current, COLUMNS.NAME, format(_("Window (%s)"), pi.description)); + ts.setValue(current, cast(int)COLUMNS.NAME, new Value(format(_("Window (%s)"), pi.description))); break; case ProcessInfoSource.SESSION: - ts.setValue(current, COLUMNS.NAME, format(_("Session (%s)"), pi.description)); + ts.setValue(current, cast(int)COLUMNS.NAME, new Value(format(_("Session (%s)"), pi.description))); break; default: - ts.setValue(current, COLUMNS.NAME, pi.description); + ts.setValue(current, cast(int)COLUMNS.NAME, new Value(pi.description)); break; } - ts.setValue(current, COLUMNS.UUID, pi.uuid); + ts.setValue(current, cast(int)COLUMNS.UUID, new Value(pi.uuid)); foreach(child; pi.children) { loadProcess(current, child); @@ -197,11 +213,15 @@ private: } public: - this(Window parent, ProcessInformation processes) { - super(getTitle(processes.source), parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [_("OK"), _("Cancel")], [GtkResponseType.OK, GtkResponseType.CANCEL]); + super(); + setTitle(getTitle(processes.source)); + setTransientFor(parent); + setModal(true); + addButton(_("Cancel"), ResponseType.Cancel); + addButton(_("OK"), ResponseType.Ok); this.processes = processes; - setDefaultResponse(GtkResponseType.OK); + setDefaultResponse(ResponseType.Ok); createUI(); } diff --git a/source/gx/tilix/cmdparams.d b/source/gx/tilix/cmdparams.d index 8a990bbf4..15ce76638 100644 --- a/source/gx/tilix/cmdparams.d +++ b/source/gx/tilix/cmdparams.d @@ -10,11 +10,11 @@ import std.regex; import std.stdio; import std.string; -import gio.ApplicationCommandLine; +import gio.application_command_line : ApplicationCommandLine; -import glib.VariantDict; -import glib.Variant : GVariant = Variant; -import glib.VariantType : GVariantType = VariantType; +import glib.variant : Variant; +import glib.variant_dict : VariantDict; +import glib.variant_type : VariantType; import gx.i18n.l10n; import gx.util.path; @@ -93,7 +93,7 @@ private: enum GEOMETRY_PATTERN_DIMENSIONS = "(?P\\d+)x(?P\\d+)"; string[] getValues(VariantDict vd, string key) { - GVariant value = vd.lookupValue(key, new GVariantType("as")); + Variant value = vd.lookupValue(key, new VariantType("as")); if (value is null) return []; else { @@ -101,13 +101,12 @@ private: } } - string getValue(VariantDict vd, string key, GVariantType vt) { - GVariant value = vd.lookupValue(key, vt); + string getValue(VariantDict vd, string key, VariantType vt) { + Variant value = vd.lookupValue(key, vt); if (value is null) return ""; else { - size_t l; - return value.getString(l); + return value.getString(); } } @@ -161,7 +160,7 @@ public: _cmdLine = acl.getCwd(); //Declare a string variant type - GVariantType vts = new GVariantType("s"); + VariantType vts = new VariantType("s"); VariantDict vd = acl.getOptionsDict(); _workingDir = validatePath(getValue(vd, CMD_WORKING_DIRECTORY, vts)); diff --git a/source/gx/tilix/colorschemes.d b/source/gx/tilix/colorschemes.d index 63d592870..4bf30c83e 100644 --- a/source/gx/tilix/colorschemes.d +++ b/source/gx/tilix/colorschemes.d @@ -12,9 +12,9 @@ import std.json; import std.path; import std.uuid; -import gdk.RGBA; +import gdk.rgba : RGBA; -import glib.Util; +import glib.global : getSystemDataDirs, getUserConfigDir; import gx.gtk.color; import gx.gtk.util; @@ -171,7 +171,7 @@ int findSchemeByColors(ColorScheme[] schemes, ColorScheme scheme) { */ ColorScheme[] loadColorSchemes() { ColorScheme[] schemes; - string[] paths = Util.getSystemDataDirs() ~ Util.getUserConfigDir(); + string[] paths = getSystemDataDirs() ~ getUserConfigDir(); foreach (path; paths) { auto fullpath = buildPath(path, APPLICATION_CONFIG_FOLDER, SCHEMES_FOLDER); trace("Loading color schemes from " ~ fullpath); diff --git a/source/gx/tilix/common.d b/source/gx/tilix/common.d index 54f18c23e..133364271 100644 --- a/source/gx/tilix/common.d +++ b/source/gx/tilix/common.d @@ -134,7 +134,10 @@ public: enum ActionType { DETACH_TERMINAL, - DETACH_SESSION + DETACH_SESSION, + SPLIT_HORIZONTAL, + SPLIT_VERTICAL, + SPLIT_AUTO } /** @@ -208,6 +211,7 @@ enum ProcessInfoSource {APPLICATION, WINDOW, SESSION, TERMINAL} */ struct ProcessInformation { ProcessInfoSource source; + string name; string description; string uuid; ProcessInformation[] children; @@ -299,5 +303,8 @@ interface ITerminal : IIdentifiable { * by the terminal. */ @property string defaultProfileUUID(); - + /** + * Execute a named action on the terminal + */ + void executeAction(string actionName); } \ No newline at end of file diff --git a/source/gx/tilix/constants.d b/source/gx/tilix/constants.d index 7541cb500..90836149c 100644 --- a/source/gx/tilix/constants.d +++ b/source/gx/tilix/constants.d @@ -40,7 +40,7 @@ immutable bool USE_COMMIT_SYNCHRONIZATION = false; /** * Compile tilix with support for VTE method vte_terminal_get_color_background_for_draw, - * only needed until VTE 0.54 is released and GtkD is updated. + * only needed until VTE 0.54 is released and the binding is updated. */ immutable bool COMPILE_VTE_BACKGROUND_COLOR = false; @@ -76,7 +76,8 @@ enum APPLICATION_ICON_NAME = "com.gexperts.Tilix"; immutable string[] APPLICATION_AUTHORS = [APPLICATION_AUTHOR]; string[] APPLICATION_CREDITS = [ N_("GTK VTE widget team, Tilix would not be possible without their work"), - N_("GtkD for providing such an excellent GTK wrapper"), + N_("GID for providing the current GTK bindings"), + N_("GtkD for providing the original GTK wrapper"), N_("Dlang.org for such an excellent language, D") ]; immutable string[] APPLICATION_ARTISTS = []; diff --git a/source/gx/tilix/customtitle.d b/source/gx/tilix/customtitle.d index aca96ee95..8495da591 100644 --- a/source/gx/tilix/customtitle.d +++ b/source/gx/tilix/customtitle.d @@ -5,26 +5,45 @@ module gx.tilix.customtitle; import std.experimental.logger; +import std.typecons : Yes; + +import gdk.event : Event; +import gdk.event_button : EventButton; +import gdk.event_focus : EventFocus; +import gdk.event_key : EventKey; + +import gio.settings : GSettings = Settings, Settings; + +import glib.source : Source; + +import gobject.global : signalHandlerBlock, signalHandlerUnblock; +import gobject.value : Value; + +import gtk.entry : Entry; +import gtk.event_box : EventBox; +import gtk.global : checkVersion; +import gtk.label : Label; +import gtk.settings : GtkSettings = Settings; +import gtk.stack : Stack; +import gtk.types : Align; +import pango.types : EllipsizeMode; +import gobject.types : ConnectFlags; +import gdk.types : ModifierType, EventType; +import glib.c.types : gulong; +import gtk.widget : Widget; + +import glib.c.functions : g_timeout_add; +import glib.c.types : GSourceFunc; + +// GID does not provide gdk.keysyms, so define the required key constants locally +private enum GdkKeysyms { + GDK_Escape = 0xff1b, + GDK_Return = 0xff0d, +} -import gdk.Event; -import gdk.Keysyms; - -import gio.Settings : GSettings = Settings; - -import gobject.Signals; -import gobject.Value; - -import gtk.Box; -import gtk.Entry; -import gtk.EventBox; -import gtk.Label; -import gtk.Settings; -import gtk.Stack; -import gtk.Widget; -import gtk.Window; -import gtk.Version; - -import gtkc.glib; +private enum MouseButton { + PRIMARY = 1, +} import gx.gtk.util; import gx.i18n.l10n; @@ -62,41 +81,38 @@ private: bool controlRequired; void createUI() { - setHalign(GtkAlign.FILL); - + setHalign(Align.Fill); lblTitle = new Label(_(APPLICATION_NAME)); - lblTitle.setHalign(GtkAlign.CENTER); + lblTitle.setHalign(Align.Center); lblTitle.getStyleContext().addClass("title"); - lblTitle.setEllipsize(PangoEllipsizeMode.START); + lblTitle.setEllipsize(EllipsizeMode.Start); eb = new EventBox(); - eb.addOnButtonPress(&onButtonPress); - eb.addOnButtonRelease(&onButtonRelease); + eb.connectButtonPressEvent(&onButtonPress); + eb.connectButtonReleaseEvent(&onButtonRelease); eb.add(lblTitle); - eb.setHalign(GtkAlign.FILL); + eb.setHalign(Align.Fill); addNamed(eb, PAGE_LABEL); - + eTitle = new Entry(); eTitle.setWidthChars(5); eTitle.setHexpand(true); - eTitle.addOnKeyPress(delegate (Event event, Widget widget) { - uint keyval; - if (event.getKeyval(keyval)) { - switch (keyval) { - case GdkKeysyms.GDK_Escape: - setViewMode(ViewMode.LABEL); - onCancelEdit.emit(); - return true; - case GdkKeysyms.GDK_Return: - onTitleChange.emit(eTitle.getText()); - setViewMode(ViewMode.LABEL); - return true; - default: - } + eTitle.connectKeyPressEvent(delegate (EventKey event, Widget widget) { + uint keyval = event.keyval; + switch (keyval) { + case GdkKeysyms.GDK_Escape: + setViewMode(ViewMode.LABEL); + onCancelEdit.emit(); + return true; + case GdkKeysyms.GDK_Return: + onTitleChange.emit(eTitle.getText()); + setViewMode(ViewMode.LABEL); + return true; + default: } return false; }); - focusOutHandlerId = eTitle.addOnFocusOut(&onFocusOut, ConnectFlags.AFTER); - if (Version.checkVersion(3,16, 0).length == 0) { + focusOutHandlerId = eTitle.connectFocusOutEvent(&onFocusOut, Yes.After); + if (checkVersion(3,16, 0).length == 0) { titleEditor = createTitleEditHelper(eTitle, TitleEditScope.WINDOW); titleEditor.onPopoverShow.connect(&onPopoverShow); titleEditor.onPopoverClosed.connect(&onPopoverClosed); @@ -107,30 +123,29 @@ private: setViewMode(ViewMode.LABEL); } - bool onButtonRelease(Event event, Widget widget) { + bool onButtonRelease(EventButton event, Widget widget) { trace("Button release"); - if (event.button.button != MouseButton.PRIMARY || !buttonDown) { + if (event.button != MouseButton.PRIMARY || !buttonDown) { tracef("Ignoring release %b", buttonDown); return false; } - if (controlRequired && !(event.button.state & ModifierType.CONTROL_MASK)) { - tracef("No control modifier, ignoring: %d", event.button.state); + if (controlRequired && !(event.state & ModifierType.ControlMask)) { + tracef("No control modifier, ignoring: %d", event.state); return false; } removeTimeout(); Value value = new Value(500); - getSettings().getProperty(GTK_DOUBLE_CLICK_TIME, value); + (cast(GtkSettings)getSettings()).getProperty(GTK_DOUBLE_CLICK_TIME, value); uint doubleClickTime = value.getInt(); timeoutID = g_timeout_add(doubleClickTime, cast(GSourceFunc)&timeoutCallback, cast(void*)this); buttonDown = false; return false; } - bool onButtonPress(Event event, Widget widget) { - if (event.button.button != MouseButton.PRIMARY) return false; - - if (event.getEventType() == EventType.DOUBLE_BUTTON_PRESS) { + bool onButtonPress(EventButton event, Widget widget) { + if (event is null || event.button != MouseButton.PRIMARY) return false; + if (event.type == EventType.DoubleButtonPress) { trace("Double click press"); buttonDown = false; removeTimeout(); @@ -141,7 +156,7 @@ private: return false; } - bool onFocusOut(Event event, Widget widget) { + bool onFocusOut(EventFocus event, Widget widget) { trace("Focus out"); removeTimeout(); setViewMode(ViewMode.LABEL); @@ -186,19 +201,19 @@ private: void removeTimeout() { if (timeoutID > 0) { - g_source_remove(timeoutID); + Source.remove(timeoutID); timeoutID = 0; } } void onPopoverShow() { trace("Popover showing"); - Signals.handlerBlock(eTitle, focusOutHandlerId); + signalHandlerBlock(eTitle, focusOutHandlerId); } void onPopoverClosed() { trace("Popover closing"); - Signals.handlerUnblock(eTitle, focusOutHandlerId); + signalHandlerUnblock(eTitle, focusOutHandlerId); } extern(C) static bool timeoutCallback(CustomTitle ct) { @@ -212,26 +227,27 @@ public: this() { super(); gsSettings = new GSettings(SETTINGS_ID); - gsSettings.addOnChanged(delegate(string key, GSettings) { + gsSettings.connectChanged(null, delegate(string key, Settings settings) { if (key == SETTINGS_CONTROL_CLICK_TITLE_KEY) { controlRequired = gsSettings.getBoolean(SETTINGS_CONTROL_CLICK_TITLE_KEY); } }); controlRequired = gsSettings.getBoolean(SETTINGS_CONTROL_CLICK_TITLE_KEY); createUI(); - addOnDestroy(delegate(Widget) { + connectDestroy(delegate(Widget w) { removeTimeout(); gsSettings.destroy(); - gsSettings = null; }); } @property string title() { return lblTitle.getText(); } - - @property void title(string title) { - lblTitle.setText(title); + @property void title(string value) { + lblTitle.setText(value); + } + void setTitle(string value) { + title = value; } GenericEvent!() onCancelEdit; diff --git a/source/gx/tilix/prefeditor/advdialog.d b/source/gx/tilix/prefeditor/advdialog.d index 8232e9484..1c4c2af2a 100644 --- a/source/gx/tilix/prefeditor/advdialog.d +++ b/source/gx/tilix/prefeditor/advdialog.d @@ -10,28 +10,32 @@ import std.experimental.logger; import std.format; import std.typecons; -import gio.Settings: GSettings = Settings; - -import glib.GException; -import glib.Regex: GRegex = Regex; - -import gtk.Box; -import gtk.Button; -import gtk.CellRendererCombo; -import gtk.CellRendererText; -import gtk.CellRendererToggle; -import gtk.CheckButton; -import gtk.Dialog; -import gtk.Label; -import gtk.ListStore; -import gtk.ScrolledWindow; -import gtk.SpinButton; -import gtk.TreeIter; -import gtk.TreePath; -import gtk.TreeView; -import gtk.TreeViewColumn; -import gtk.Window; - +import gio.settings: GSettings = Settings; +import gio.types : SettingsBindFlags; + +import glib.error; +import glib.regex: GRegex = Regex; +import glib.types : RegexCompileFlags, RegexMatchFlags; + +import gtk.box; +import gtk.button; +import gtk.cell_renderer_combo; +import gtk.cell_renderer_text; +import gtk.cell_renderer_toggle; +import gtk.check_button; +import gtk.dialog; +import gtk.label; +import gtk.list_store; +import gtk.scrolled_window; +import gtk.spin_button; +import gtk.tree_iter; +import gtk.tree_path; +import gtk.types : Align, DialogFlags, IconSize, Orientation, PolicyType, ResponseType, ShadowType; +import gtk.tree_view; +import gtk.tree_view_column; +import gtk.window; + +import gx.gtk.util : GTypes; import gx.i18n.l10n; import gx.gtk.util; import gx.util.string; @@ -56,28 +60,56 @@ private: Label lblErrors; + TreeIter getSelectedIter(TreeView treeView) { + import gtk.tree_model : TreeModel; + import gtk.tree_selection : TreeSelection; + TreeModel model; + TreeIter iter; + if (treeView.getSelection().getSelected(model, iter)) { + return iter; + } + return null; + } + + string getValueString(ListStore store, TreeIter iter, int column) { + import gobject.value : Value; + Value val; + store.getValue(iter, column, val); + return val.getString(); + } + + bool getValueBool(ListStore store, TreeIter iter, int column) { + import gobject.value : Value; + Value val; + store.getValue(iter, column, val); + return val.getBoolean(); + } + void createUI(string[] links) { setAllMargins(getContentArea(), 18); - Box box = new Box(Orientation.VERTICAL, 6); + Box box = new Box(Orientation.Vertical, 6); - ls = new ListStore([GType.STRING, GType.STRING, GType.BOOLEAN]); + import gobject.value : Value; + ls = ListStore.new_([GTypes.STRING, GTypes.STRING, GTypes.BOOLEAN]); foreach(link; links) { foreach(value; csvReader!(Tuple!(string, string, string))(link)) { - TreeIter iter = ls.createIter(); - ls.setValue(iter, COLUMN_REGEX, value[0]); - ls.setValue(iter, COLUMN_CMD, value[1]); + TreeIter iter; + ls.append(iter); + ls.setValue(iter, COLUMN_REGEX, new Value(value[0])); + ls.setValue(iter, COLUMN_CMD, new Value(value[1])); try { - ls.setValue(iter, COLUMN_CASE, to!bool(value[2])); + ls.setValue(iter, COLUMN_CASE, new Value(to!bool(value[2]))); } catch (Exception e) { - ls.setValue(iter, COLUMN_CASE, false); + ls.setValue(iter, COLUMN_CASE, new Value(false)); } } } - tv = new TreeView(ls); + tv = new TreeView(); + tv.setModel(ls); tv.setActivateOnSingleClick(false); - tv.addOnCursorChanged(delegate(TreeView) { + tv.connectCursorChanged(delegate(TreeView v) { updateUI(); }); tv.setHeadersVisible(true); @@ -85,85 +117,96 @@ private: //Regex column CellRendererText crtRegex = new CellRendererText(); crtRegex.setProperty("editable", 1); - crtRegex.addOnEdited(delegate(string path, string newText, CellRendererText) { + crtRegex.connectEdited(delegate(string path, string newText, CellRendererText crt) { TreeIter iter = new TreeIter(); - ls.getIter(iter, new TreePath(path)); - ls.setValue(iter, COLUMN_REGEX, newText); + ls.getIter(iter, TreePath.newFromString(path)); + ls.setValue(iter, COLUMN_REGEX, new Value(newText)); updateUI(); }); - TreeViewColumn column = new TreeViewColumn(_("Regex"), crtRegex, "text", COLUMN_REGEX); + TreeViewColumn column = new TreeViewColumn(); + column.setTitle(_("Regex")); + column.packStart(crtRegex, true); + column.addAttribute(crtRegex, "text", COLUMN_REGEX); column.setMinWidth(200); tv.appendColumn(column); //Command column CellRendererText crtCommand = new CellRendererText(); crtCommand.setProperty("editable", 1); - crtCommand.addOnEdited(delegate(string path, string newText, CellRendererText) { + crtCommand.connectEdited(delegate(string path, string newText, CellRendererText crt) { TreeIter iter = new TreeIter(); - ls.getIter(iter, new TreePath(path)); - ls.setValue(iter, COLUMN_CMD, newText); + ls.getIter(iter, TreePath.newFromString(path)); + ls.setValue(iter, COLUMN_CMD, new Value(newText)); }); - column = new TreeViewColumn(_("Command"), crtCommand, "text", COLUMN_CMD); + column = new TreeViewColumn(); + column.setTitle(_("Command")); + column.packStart(crtCommand, true); + column.addAttribute(crtCommand, "text", COLUMN_CMD); column.setMinWidth(200); tv.appendColumn(column); //Case Insensitive Column CellRendererToggle crtCase = new CellRendererToggle(); crtCase.setActivatable(true); - crtCase.addOnToggled(delegate(string path, CellRendererToggle crt) { + crtCase.connectToggled(delegate(string path, CellRendererToggle crt) { TreeIter iter = new TreeIter(); - ls.getIter(iter, new TreePath(path)); - ls.setValue(iter, COLUMN_CASE, !crt.getActive()); + ls.getIter(iter, TreePath.newFromString(path)); + ls.setValue(iter, COLUMN_CASE, new Value(!crt.getActive())); }); - column = new TreeViewColumn(_("Case Insensitive"), crtCase, "active", COLUMN_CASE); + column = new TreeViewColumn(); + column.setTitle(_("Case Insensitive")); + column.packStart(crtCase, true); + column.addAttribute(crtCase, "active", COLUMN_CASE); tv.appendColumn(column); - ScrolledWindow sc = new ScrolledWindow(tv); - sc.setShadowType(ShadowType.ETCHED_IN); - sc.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + ScrolledWindow sc = new ScrolledWindow(null, null); + sc.add(tv); + sc.setShadowType(ShadowType.EtchedIn); + sc.setPolicy(PolicyType.Never, PolicyType.Automatic); sc.setHexpand(true); sc.setVexpand(true); sc.setSizeRequest(-1, 250); box.add(sc); - Box buttons = new Box(Orientation.HORIZONTAL, 0); + Box buttons = new Box(Orientation.Horizontal, 0); buttons.getStyleContext().addClass("linked"); - - Button btnAdd = new Button("list-add-symbolic", IconSize.BUTTON); + + Button btnAdd = Button.newFromIconName("list-add-symbolic", IconSize.Button); btnAdd.setTooltipText(_("Add")); - btnAdd.addOnClicked(delegate(Button) { - ls.createIter(); + btnAdd.connectClicked(delegate(Button btn) { + TreeIter iter; + ls.append(iter); selectRow(tv, ls.iterNChildren(null) - 1, null); }); buttons.add(btnAdd); - btnDelete = new Button("list-remove-symbolic", IconSize.BUTTON); + btnDelete = Button.newFromIconName("list-remove-symbolic", IconSize.Button); btnDelete.setTooltipText(_("Delete")); - btnDelete.addOnClicked(delegate(Button) { - TreeIter selected = tv.getSelectedIter(); - if (selected) { + btnDelete.connectClicked(delegate(Button btn) { + TreeIter selected = getSelectedIter(tv); + if (selected !is null) { ls.remove(selected); } }); buttons.add(btnDelete); - btnMoveUp = new Button("pan-up-symbolic", IconSize.BUTTON); + btnMoveUp = Button.newFromIconName("pan-up-symbolic", IconSize.Button); btnMoveUp.setTooltipText(_("Move up")); - btnMoveUp.addOnClicked(delegate(Button) { - TreeIter selected = tv.getSelectedIter(); + btnMoveUp.connectClicked(delegate(Button btn) { + TreeIter selected = getSelectedIter(tv); if (selected !is null) { - TreeIter previous = selected.copy(selected); + TreeIter previous = selected.copy(); if (ls.iterPrevious(previous)) ls.swap(selected, previous); } }); buttons.add(btnMoveUp); - btnMoveDown = new Button("pan-down-symbolic", IconSize.BUTTON); + btnMoveDown = Button.newFromIconName("pan-down-symbolic", IconSize.Button); btnMoveDown.setTooltipText(_("Move down")); - btnMoveDown.addOnClicked(delegate(Button) { - TreeIter selected = tv.getSelectedIter(); + btnMoveDown.connectClicked(delegate(Button btn) { + TreeIter selected = getSelectedIter(tv); if (selected !is null) { - TreeIter next = selected.copy(selected); + TreeIter next = selected.copy(); if (ls.iterNext(next)) ls.swap(selected, next); } }); @@ -180,28 +223,32 @@ private: } void updateUI() { - TreeIter selected = tv.getSelectedIter(); + TreeIter selected = getSelectedIter(tv); btnDelete.setSensitive(selected !is null); - btnMoveUp.setSensitive(selected !is null && selected.getTreePath().getIndices()[0] > 0); - btnMoveDown.setSensitive(selected !is null && selected.getTreePath().getIndices()[0] < ls.iterNChildren(null) - 1); - setResponseSensitive(GtkResponseType.APPLY, validateRegex(ls, COLUMN_REGEX, lblErrors)); + btnMoveUp.setSensitive(selected !is null && ls.getPath(selected).getIndices()[0] > 0); + btnMoveDown.setSensitive(selected !is null && ls.getPath(selected).getIndices()[0] < ls.iterNChildren(null) - 1); + setResponseSensitive(ResponseType.Apply, validateRegex(ls, COLUMN_REGEX, lblErrors)); } - public: this(Window parent, string[] links) { - super(_("Edit Custom Links"), parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [_("Apply"), _("Cancel")], [GtkResponseType.APPLY, GtkResponseType.CANCEL]); - setDefaultResponse(GtkResponseType.APPLY); + super(); + setTitle(_("Edit Custom Links")); + setTransientFor(parent); + setModal(true); + addButton(_("Cancel"), ResponseType.Cancel); + addButton(_("Apply"), ResponseType.Apply); + setDefaultResponse(ResponseType.Apply); createUI(links); } string[] getLinks() { string[] results; foreach (TreeIter iter; TreeIterRange(ls)) { - string regex = ls.getValueString(iter, COLUMN_REGEX); + string regex = getValueString(ls, iter, COLUMN_REGEX); if (regex.length == 0) continue; results ~= escapeCSV(regex) ~ ',' ~ - escapeCSV(ls.getValueString(iter, COLUMN_CMD)) ~ ',' ~ - to!string(ls.getValue(iter, COLUMN_CASE).getBoolean()); + escapeCSV(getValueString(ls, iter, COLUMN_CMD)) ~ ',' ~ + to!string(getValueBool(ls, iter, COLUMN_CASE)); } return results; } @@ -226,99 +273,131 @@ private: string[string] localizedActions; + TreeIter getSelectedIter(TreeView treeView) { + import gtk.tree_model : TreeModel; + TreeModel model; + TreeIter iter; + if (treeView.getSelection().getSelected(model, iter)) { + return iter; + } + return null; + } + + string getValueString(ListStore store, TreeIter iter, int column) { + import gobject.value : Value; + Value val; + store.getValue(iter, column, val); + return val.getString(); + } + void createUI(GSettings gs, bool showLineSettings) { + import gobject.value : Value; string[] triggers = gs.getStrv(SETTINGS_ALL_TRIGGERS_KEY); setAllMargins(getContentArea(), 18); - Box box = new Box(Orientation.HORIZONTAL, 6); + Box box = new Box(Orientation.Horizontal, 6); - ls = new ListStore([GType.STRING, GType.STRING, GType.STRING]); + ls = ListStore.new_([GTypes.STRING, GTypes.STRING, GTypes.STRING]); foreach(trigger; triggers) { foreach(value; csvReader!(Tuple!(string, string, string))(trigger)) { - TreeIter iter = ls.createIter(); - ls.setValue(iter, COLUMN_REGEX, value[0]); - ls.setValue(iter, COLUMN_ACTION, _(value[1])); - ls.setValue(iter, COLUMN_PARAMETERS, value[2]); + TreeIter iter; + ls.append(iter); + ls.setValue(iter, COLUMN_REGEX, new Value(value[0])); + ls.setValue(iter, COLUMN_ACTION, new Value(_(value[1]))); + ls.setValue(iter, COLUMN_PARAMETERS, new Value(value[2])); } } - tv = new TreeView(ls); + tv = new TreeView(); + tv.setModel(ls); tv.setActivateOnSingleClick(false); - tv.addOnCursorChanged(delegate(TreeView) { + tv.connectCursorChanged(delegate(TreeView v) { updateUI(); }); tv.setHeadersVisible(true); //Regex column CellRendererText crtRegex = new CellRendererText(); crtRegex.setProperty("editable", 1); - crtRegex.addOnEdited(delegate(string path, string newText, CellRendererText) { + crtRegex.connectEdited(delegate(string path, string newText, CellRendererText crt) { TreeIter iter = new TreeIter(); - ls.getIter(iter, new TreePath(path)); - ls.setValue(iter, COLUMN_REGEX, newText); + ls.getIter(iter, TreePath.newFromString(path)); + ls.setValue(iter, COLUMN_REGEX, new Value(newText)); updateUI(); }); - TreeViewColumn column = new TreeViewColumn(_("Regex"), crtRegex, "text", COLUMN_REGEX); + TreeViewColumn column = new TreeViewColumn(); + column.setTitle(_("Regex")); + column.packStart(crtRegex, true); + column.addAttribute(crtRegex, "text", COLUMN_REGEX); column.setMinWidth(200); tv.appendColumn(column); //Action Column CellRendererCombo crtAction = new CellRendererCombo(); - ListStore lsActions = new ListStore([GType.STRING]); + ListStore lsActions = ListStore.new_([GTypes.STRING]); foreach(value; SETTINGS_PROFILE_TRIGGER_ACTION_VALUES) { - TreeIter iter = lsActions.createIter(); - lsActions.setValue(iter, 0, _(value)); + TreeIter iter; + lsActions.append(iter); + lsActions.setValue(iter, 0, new Value(_(value))); localizedActions[_(value)] = value; } - import gtkc.gobject: g_object_set; - import glib.Str: Str; - g_object_set(crtAction.getCellRendererComboStruct, Str.toStringz("model"), lsActions.getListStoreStruct(), null); + crtAction.setProperty("model", lsActions); crtAction.setProperty("editable", 1); crtAction.setProperty("has-entry", 0); crtAction.setProperty("text-column", 0); - crtAction.addOnChanged(delegate(string path, TreeIter actionIter, CellRendererCombo) { + crtAction.connectChanged(delegate(string path, TreeIter actionIter, CellRendererCombo crc) { TreeIter iter = new TreeIter(); - ls.getIter(iter, new TreePath(path)); - string action = lsActions.getValueString(actionIter, 0); + ls.getIter(iter, TreePath.newFromString(path)); + Value val; + lsActions.getValue(actionIter, 0, val); + string action = val.getString(); if (iter !is null) { - ls.setValue(iter, COLUMN_ACTION, action); + ls.setValue(iter, COLUMN_ACTION, new Value(action)); } }); - column = new TreeViewColumn(_("Action"), crtAction, "text", COLUMN_ACTION); + column = new TreeViewColumn(); + column.setTitle(_("Action")); + column.packStart(crtAction, true); + column.addAttribute(crtAction, "text", COLUMN_ACTION); column.setMinWidth(150); tv.appendColumn(column); //Parameter column CellRendererText crtParameter = new CellRendererText(); crtParameter.setProperty("editable", 1); - crtParameter.addOnEdited(delegate(string path, string newText, CellRendererText) { + crtParameter.connectEdited(delegate(string path, string newText, CellRendererText crt) { TreeIter iter = new TreeIter(); - ls.getIter(iter, new TreePath(path)); - ls.setValue(iter, COLUMN_PARAMETERS, newText); + ls.getIter(iter, TreePath.newFromString(path)); + ls.setValue(iter, COLUMN_PARAMETERS, new Value(newText)); }); - column = new TreeViewColumn(_("Parameter"), crtParameter, "text", COLUMN_PARAMETERS); + column = new TreeViewColumn(); + column.setTitle(_("Parameter")); + column.packStart(crtParameter, true); + column.addAttribute(crtParameter, "text", COLUMN_PARAMETERS); column.setMinWidth(200); tv.appendColumn(column); - ScrolledWindow sc = new ScrolledWindow(tv); - sc.setShadowType(ShadowType.ETCHED_IN); - sc.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + ScrolledWindow sc = new ScrolledWindow(null, null); + sc.add(tv); + sc.setShadowType(ShadowType.EtchedIn); + sc.setPolicy(PolicyType.Never, PolicyType.Automatic); sc.setHexpand(true); sc.setVexpand(true); sc.setSizeRequest(-1, 250); box.add(sc); - Box buttons = new Box(Orientation.VERTICAL, 6); - Button btnAdd = new Button(_("Add")); - btnAdd.addOnClicked(delegate(Button) { - ls.createIter(); + Box buttons = new Box(Orientation.Vertical, 6); + Button btnAdd = Button.newWithLabel(_("Add")); + btnAdd.connectClicked(delegate(Button btn) { + TreeIter iter; + ls.append(iter); selectRow(tv, ls.iterNChildren(null) - 1, null); }); buttons.add(btnAdd); - btnDelete = new Button(_("Delete")); - btnDelete.addOnClicked(delegate(Button) { - TreeIter selected = tv.getSelectedIter(); + btnDelete = Button.newWithLabel(_("Delete")); + btnDelete.connectClicked(delegate(Button btn) { + TreeIter selected = getSelectedIter(tv); if (selected) { ls.remove(selected); } @@ -331,16 +410,15 @@ private: if (showLineSettings) { // Maximum number of lines to check for triggers when content change is // received from VTE with a block of text - Box bLines = new Box(Orientation.HORIZONTAL, 6); + Box bLines = new Box(Orientation.Horizontal, 6); bLines.setMarginTop(6); - CheckButton cbTriggerLimit = new CheckButton(_("Limit number of lines for trigger processing to:")); - gs.bind(SETTINGS_TRIGGERS_UNLIMITED_LINES_KEY, cbTriggerLimit, "active", GSettingsBindFlags.DEFAULT | GSettingsBindFlags.INVERT_BOOLEAN); - - SpinButton sbLines = new SpinButton(256.0, double.max, 256.0); - gs.bind(SETTINGS_TRIGGERS_LINES_KEY, sbLines, "value", GSettingsBindFlags.DEFAULT); + CheckButton cbTriggerLimit = CheckButton.newWithLabel(_("Limit number of lines for trigger processing to:")); + gs.bind(SETTINGS_TRIGGERS_UNLIMITED_LINES_KEY, cbTriggerLimit, "active", SettingsBindFlags.Default | SettingsBindFlags.InvertBoolean); + SpinButton sbLines = SpinButton.newWithRange(256.0, double.max, 256.0); + gs.bind(SETTINGS_TRIGGERS_LINES_KEY, sbLines, "value", SettingsBindFlags.Default); gs.bind(SETTINGS_TRIGGERS_UNLIMITED_LINES_KEY, sbLines, "sensitive", - GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY | GSettingsBindFlags.INVERT_BOOLEAN); + SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity | SettingsBindFlags.InvertBoolean); bLines.add(cbTriggerLimit); bLines.add(sbLines); @@ -353,25 +431,30 @@ private: } void updateUI() { - btnDelete.setSensitive(tv.getSelectedIter() !is null); - setResponseSensitive(GtkResponseType.APPLY, validateRegex(ls, COLUMN_REGEX, lblErrors)); + btnDelete.setSensitive(getSelectedIter(tv) !is null); + setResponseSensitive(ResponseType.Apply, validateRegex(ls, COLUMN_REGEX, lblErrors)); } public: this(Window parent, GSettings gs, bool showLineSettings = false) { - super(_("Edit Triggers"), parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [_("Apply"), _("Cancel")], [GtkResponseType.APPLY, GtkResponseType.CANCEL]); - setDefaultResponse(GtkResponseType.APPLY); + super(); + setTitle(_("Edit Triggers")); + setTransientFor(parent); + setModal(true); + addButton(_("Cancel"), ResponseType.Cancel); + addButton(_("Apply"), ResponseType.Apply); + setDefaultResponse(ResponseType.Apply); createUI(gs, showLineSettings); } string[] getTriggers() { string[] results; foreach (TreeIter iter; TreeIterRange(ls)) { - string regex = ls.getValueString(iter, COLUMN_REGEX); + string regex = getValueString(ls, iter, COLUMN_REGEX); if (regex.length == 0) continue; results ~= escapeCSV(regex) ~ ',' ~ - escapeCSV(localizedActions[ls.getValueString(iter, COLUMN_ACTION)]) ~ ',' ~ - escapeCSV(ls.getValueString(iter, COLUMN_PARAMETERS)); + escapeCSV(localizedActions[getValueString(ls, iter, COLUMN_ACTION)]) ~ ',' ~ + escapeCSV(getValueString(ls, iter, COLUMN_PARAMETERS)); } return results; } @@ -381,7 +464,7 @@ private: Label createErrorLabel() { Label lblErrors = new Label(""); - lblErrors.setHalign(GtkAlign.START); + lblErrors.setHalign(Align.Start); lblErrors.setMarginTop(12); lblErrors.getStyleContext().addClass("tilix-error"); lblErrors.setNoShowAll(true); @@ -390,17 +473,20 @@ Label createErrorLabel() { } bool validateRegex(ListStore ls, int regexColumn, Label lblErrors) { + import gobject.value : Value; bool valid = true; string errors; int index = 0; foreach (TreeIter iter; TreeIterRange(ls)) { index++; try { - string regex = ls.getValueString(iter, regexColumn); + Value val; + ls.getValue(iter, regexColumn, val); + string regex = val.getString(); if (regex.length > 0) { - GRegex check = new GRegex(regex, GRegexCompileFlags.OPTIMIZE, cast(GRegexMatchFlags) 0); + GRegex check = new GRegex(regex, RegexCompileFlags.Optimize, cast(RegexMatchFlags) 0); } - } catch (GException ge) { + } catch (ErrorWrap ge) { if (errors.length > 0) errors ~= "\n"; errors ~= format(_("Row %d: "), index) ~ ge.msg; valid = false; diff --git a/source/gx/tilix/prefeditor/bookmarkeditor.d b/source/gx/tilix/prefeditor/bookmarkeditor.d index 42b16d714..f61a60930 100644 --- a/source/gx/tilix/prefeditor/bookmarkeditor.d +++ b/source/gx/tilix/prefeditor/bookmarkeditor.d @@ -6,12 +6,15 @@ module gx.tilix.prefeditor.bookmarkeditor; import std.experimental.logger; -import gtk.Box; -import gtk.Button; -import gtk.ScrolledWindow; -import gtk.TreeIter; -import gtk.TreePath; -import gtk.Window; +import gtk.box; +import gtk.button; +import gtk.scrolled_window; +import gtk.tree_iter; +import gtk.tree_path; +import gtk.tree_view : TreeView; +import gtk.tree_view_column : TreeViewColumn; +import gtk.types : IconSize, Orientation, PolicyType, ResponseType, SelectionMode, ShadowType; +import gtk.window; import gx.i18n.l10n; @@ -39,43 +42,44 @@ private: tv = new BMTreeView(false, false, true); tv.setActivateOnSingleClick(false); tv.setHeadersVisible(false); - tv.getSelection().setMode(SelectionMode.SINGLE); - tv.addOnCursorChanged(delegate(TreeView) { + tv.getSelection().setMode(SelectionMode.Single); + tv.connectCursorChanged(delegate(TreeView v) { updateUI(); }); - tv.addOnRowActivated(delegate(TreePath, TreeViewColumn, TreeView) { + tv.connectRowActivated(delegate(TreePath p, TreeViewColumn c, TreeView v) { editBookmark(btnEdit); }); - ScrolledWindow sw = new ScrolledWindow(tv); - sw.setShadowType(ShadowType.ETCHED_IN); - sw.setPolicy(PolicyType.AUTOMATIC, PolicyType.AUTOMATIC); + ScrolledWindow sw = new ScrolledWindow(null, null); + sw.add(tv); + sw.setShadowType(ShadowType.EtchedIn); + sw.setPolicy(PolicyType.Automatic, PolicyType.Automatic); sw.setHexpand(true); sw.setVexpand(true); add(sw); - Box bButtons = new Box(Orientation.HORIZONTAL, 0); + Box bButtons = new Box(Orientation.Horizontal, 0); bButtons.getStyleContext().addClass("linked"); - Button btnAdd = new Button("list-add-symbolic", IconSize.BUTTON); + Button btnAdd = Button.newFromIconName("list-add-symbolic", IconSize.Button); btnAdd.setTooltipText(_("Add bookmark")); - btnAdd.addOnClicked(&addBookmark); + btnAdd.connectClicked(&addBookmark); bButtons.add(btnAdd); - btnEdit = new Button("input-tablet-symbolic", IconSize.BUTTON); + btnEdit = Button.newFromIconName("input-tablet-symbolic", IconSize.Button); btnEdit.setTooltipText(_("Edit bookmark")); - btnEdit.addOnClicked(&editBookmark); + btnEdit.connectClicked(&editBookmark); bButtons.add(btnEdit); - btnDelete = new Button("list-remove-symbolic", IconSize.BUTTON); + btnDelete = Button.newFromIconName("list-remove-symbolic", IconSize.Button); btnDelete.setTooltipText(_("Delete bookmark")); - btnDelete.addOnClicked(&deleteBookmark); + btnDelete.connectClicked(&deleteBookmark); bButtons.add(btnDelete); - btnUnselect = new Button("edit-clear-symbolic", IconSize.BUTTON); + btnUnselect = Button.newFromIconName("edit-clear-symbolic", IconSize.Button); btnUnselect.setTooltipText(_("Unselect bookmark")); - btnUnselect.addOnClicked(&unselectBookmark); + btnUnselect.connectClicked(&unselectBookmark); bButtons.add(btnUnselect); add(bButtons); @@ -84,7 +88,7 @@ private: } void updateUI() { - TreeIter selected = tv.getSelectedIter(); + Bookmark selected = tv.getSelectedBookmark(); btnEdit.setSensitive(selected !is null); btnDelete.setSensitive(selected !is null); btnUnselect.setSensitive(selected !is null); @@ -96,7 +100,7 @@ private: be.destroy(); } be.showAll(); - if (be.run() == ResponseType.OK) { + if (be.run() == ResponseType.Ok) { Bookmark bm = be.create(); tv.addBookmark(bm); } @@ -110,7 +114,7 @@ private: be.destroy(); } be.showAll(); - if (be.run() == ResponseType.OK) { + if (be.run() == ResponseType.Ok) { be.update(bm); tv.updateBookmark(bm); } @@ -121,12 +125,12 @@ private: } void unselectBookmark(Button button) { - tv.getSelection().unselectIter(tv.getSelectedIter()); + tv.getSelection().unselectAll(); } public: this() { - super(Orientation.VERTICAL, 6); + super(Orientation.Vertical, 6); setAllMargins(this, 18); setMarginBottom(6); createUI(); diff --git a/source/gx/tilix/prefeditor/common.d b/source/gx/tilix/prefeditor/common.d index 86fb363b4..00ac61df0 100644 --- a/source/gx/tilix/prefeditor/common.d +++ b/source/gx/tilix/prefeditor/common.d @@ -7,14 +7,15 @@ module gx.tilix.prefeditor.common; import std.format; import std.experimental.logger; -import gio.Settings: GSettings = Settings; +import gio.settings: GSettings = Settings; -import gtk.Box; -import gtk.Button; -import gtk.Grid; -import gtk.Label; -import gtk.Window; -import gtk.Version; +import gtk.box; +import gtk.button; +import gtk.grid; +import gtk.label; +import gtk.types : Align, ResponseType; +import gtk.window; +import gtk.global : checkVersion; import gx.gtk.vte; import gx.i18n.l10n; @@ -36,18 +37,17 @@ void createAdvancedUI(Grid grid, ref uint row, GSettings delegate() scb, bool sh // Custom Links Section Label lblCustomLinks = new Label(format("%s", _("Custom Links"))); lblCustomLinks.setUseMarkup(true); - lblCustomLinks.setHalign(GtkAlign.START); + lblCustomLinks.setHalign(Align.Start); grid.attach(lblCustomLinks, 0, row, 3, 1); row++; string customLinksDescription = _("A list of user defined links that can be clicked on in the terminal based on regular expression definitions."); grid.attach(createDescriptionLabel(customLinksDescription), 0, row, 2, 1); - Button btnEditLink = new Button(_("Edit")); - btnEditLink.setHalign(GtkAlign.FILL); - btnEditLink.setValign(GtkAlign.CENTER); - - btnEditLink.addOnClicked(delegate(Button) { + Button btnEditLink = Button.newWithLabel(_("Edit")); + btnEditLink.setHalign(Align.Fill); + btnEditLink.setValign(Align.Center); + btnEditLink.connectClicked(delegate(Button btn) { GSettings gs = scb(); string[] links = gs.getStrv(SETTINGS_ALL_CUSTOM_HYPERLINK_KEY); EditCustomLinksDialog dlg = new EditCustomLinksDialog(cast(Window) grid.getToplevel(), links); @@ -55,7 +55,7 @@ void createAdvancedUI(Grid grid, ref uint row, GSettings delegate() scb, bool sh dlg.destroy(); } dlg.showAll(); - if (dlg.run() == ResponseType.APPLY) { + if (dlg.run() == ResponseType.Apply) { gs.setStrv(SETTINGS_ALL_CUSTOM_HYPERLINK_KEY, dlg.getLinks()); } }); @@ -66,7 +66,7 @@ void createAdvancedUI(Grid grid, ref uint row, GSettings delegate() scb, bool sh // Triggers Section Label lblTriggers = new Label(format("%s", _("Triggers"))); lblTriggers.setUseMarkup(true); - lblTriggers.setHalign(GtkAlign.START); + lblTriggers.setHalign(Align.Start); lblTriggers.setMarginTop(12); grid.attach(lblTriggers, 0, row, 3, 1); row++; @@ -74,18 +74,17 @@ void createAdvancedUI(Grid grid, ref uint row, GSettings delegate() scb, bool sh string triggersDescription = _("Triggers are regular expressions that are used to check against output text in the terminal. When a match is detected the configured action is executed."); grid.attach(createDescriptionLabel(triggersDescription), 0, row, 2, 1); - Button btnEditTriggers = new Button(_("Edit")); - btnEditTriggers.setHalign(GtkAlign.FILL); - btnEditTriggers.setValign(GtkAlign.CENTER); - - btnEditTriggers.addOnClicked(delegate(Button) { + Button btnEditTriggers = Button.newWithLabel(_("Edit")); + btnEditTriggers.setHalign(Align.Fill); + btnEditTriggers.setValign(Align.Center); + btnEditTriggers.connectClicked(delegate(Button btn) { GSettings gs = scb(); EditTriggersDialog dlg = new EditTriggersDialog(cast(Window) grid.getToplevel(), gs, showTriggerLineSettings); scope (exit) { dlg.destroy(); } dlg.showAll(); - if (dlg.run() == ResponseType.APPLY) { + if (dlg.run() == ResponseType.Apply) { gs.setStrv(SETTINGS_ALL_TRIGGERS_KEY, dlg.getTriggers()); } }); @@ -102,8 +101,8 @@ Label createDescriptionLabel(string desc) { lblDescription.setUseMarkup(true); lblDescription.setSensitive(false); lblDescription.setLineWrap(true); - lblDescription.setHalign(GtkAlign.START); - if (Version.checkVersion(3, 16, 0).length == 0) { + lblDescription.setHalign(Align.Start); + if (checkVersion(3, 16, 0).length == 0) { lblDescription.setXalign(0.0); } lblDescription.setMaxWidthChars(70); diff --git a/source/gx/tilix/prefeditor/prefdialog.d b/source/gx/tilix/prefeditor/prefdialog.d index 25d30cb87..6424cefab 100644 --- a/source/gx/tilix/prefeditor/prefdialog.d +++ b/source/gx/tilix/prefeditor/prefdialog.d @@ -14,69 +14,82 @@ import std.string; import std.typecons : No; import std.variant; -import gdk.Event; -import gdk.Screen; - -import gio.Menu: GMenu = Menu; -import gio.Settings: GSettings = Settings; -import gio.SimpleAction; -import gio.SimpleActionGroup; - -import glib.Variant: GVariant = Variant; - -import gobject.ObjectG; -import gobject.Signals; -import gobject.Value; - -import gtk.AccelGroup; -import gtk.Application; -import gtk.ApplicationWindow; -import gtk.Box; -import gtk.Button; -import gtk.CellRendererAccel; -import gtk.CellRendererText; -import gtk.CellRendererToggle; -import gtk.CheckButton; -import gtk.ComboBox; -import gtk.Dialog; -import gtk.Entry; -import gtk.FileChooserButton; -import gtk.FileFilter; -import gtk.Grid; -import gtk.HeaderBar; -import gtk.Image; -import gtk.Label; -import gtk.ListBox; -import gtk.ListBoxRow; -import gtk.ListStore; -import gtk.MenuButton; -import gtk.MessageDialog; -import gtk.Popover; -import gtk.Revealer; -import gtk.Scale; -import gtk.ScrolledWindow; -import gtk.SearchEntry; -import gtk.Separator; -import gtk.Settings; -import gtk.SizeGroup; -import gtk.SpinButton; -import gtk.Stack; -import gtk.Switch; -import gtk.ToggleButton; -import gtk.TreeIter; -import gtk.TreeModel; -import gtk.TreeModelFilter; -import gtk.TreePath; -import gtk.TreeStore; -import gtk.TreeView; -import gtk.TreeViewColumn; -import gtk.Version; -import gtk.Widget; -import gtk.Window; - -import vte.Terminal; +import gdk.event; +import gdk.screen; + +import gio.menu: GMenu = Menu; +import gio.settings: GSettings = Settings; +import gio.types : SettingsBindFlags; +import gio.simple_action; +import gio.simple_action_group; + +import glib.variant: GVariant = Variant; + +import gobject.object; +import gobject.value; + +import gtk.accel_group; +import gtk.adjustment; +import gtk.application; +import gtk.application_window; +import gtk.box; +import gtk.button; +import gtk.cell_renderer_accel; +import gtk.cell_renderer_text; +import gtk.cell_renderer_toggle; +import gtk.check_button; +import gtk.combo_box; +import gtk.dialog; +import gtk.entry; +import gtk.file_chooser_button; +import gtk.file_filter; +import gtk.grid; +import gtk.header_bar; +import gtk.image; +import gtk.label; +import gtk.list_box; +import gtk.list_box_row; +import gtk.list_store; +import gtk.menu_button; +import gtk.message_dialog; +import gtk.popover; +import gtk.revealer; +import gtk.scale; +import gtk.scrolled_window; +import gtk.search_entry; +import gtk.separator; +import gtk.settings; +import gtk.size_group; +import gtk.spin_button; +import gtk.stack; +import gtk.switch_; +import gtk.toggle_button; +import gtk.tree_iter; +import gtk.tree_model; +import gtk.tree_model_filter; +import gtk.tree_path; +import gtk.tree_store; +import gtk.tree_view; +import gtk.tree_view_column; +import gtk.global : checkVersion, getMajorVersion, getMinorVersion, acceleratorParse, acceleratorGetLabel, acceleratorName; +import gtk.widget; +import gtk.c.types : GtkTreeModel, GtkTreeIter, GtkWidget, GtkWindow; +import gtk.c.functions : gtk_message_dialog_new; +import gtk.types : Align, ButtonsType, CellRendererAccelMode, DialogFlags, FileChooserAction, IconSize, MessageType, Orientation, PolicyType, PositionType, ReliefStyle, ResponseType, SelectionMode, ShadowType, SizeGroupMode; +import gdk.types : ModifierType, WindowTypeHint; +import gdk.c.types : GdkModifierType; +import glib.c.types : GError; + +import gid.gid : No; + +import gobject.param_spec : ParamSpec; +import gobject.object : ObjectWrap; +import gtk.window; + +import vte.terminal; import gx.gtk.actions; +import gx.gtk.util : GTypes; import gx.gtk.dialog; import gx.gtk.resource; import gx.gtk.settings; @@ -127,9 +140,9 @@ private: //Create Listbox lbSide = new ListBox(); lbSide.setCanFocus(true); - lbSide.setSelectionMode(SelectionMode.BROWSE); + lbSide.setSelectionMode(SelectionMode.Browse); lbSide.setVexpand(true); - lbSide.addOnRowSelected(&onRowSelected); + lbSide.connectRowSelected(&onRowSelected); //Create Stack and boxes pages = new Stack(); @@ -156,7 +169,7 @@ private: addNonProfileRow(new GenericPreferenceRow(N_("Bookmarks"), _("Bookmarks"))); ShortcutPreferences sp = new ShortcutPreferences(gsSettings); - searchButton.addOnToggled(delegate(ToggleButton button) { + searchButton.connectToggled(delegate(ToggleButton button) { sp.toggleShortcutsFind(); }); pages.addTitled(sp, N_("Shortcuts"), _("Shortcuts")); @@ -177,41 +190,41 @@ private: addNonProfileRow(createProfileTitleRow()); loadProfiles(); - ScrolledWindow sw = new ScrolledWindow(lbSide); - sw.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); - sw.setShadowType(ShadowType.NONE); + ScrolledWindow sw = new ScrolledWindow(null, null); + sw.add(lbSide); + sw.setPolicy(PolicyType.Never, PolicyType.Automatic); + sw.setShadowType(ShadowType.None); sw.setSizeRequest(220, -1); - Box bButtons = new Box(Orientation.HORIZONTAL, 0); + Box bButtons = new Box(Orientation.Horizontal, 0); bButtons.getStyleContext().addClass("linked"); setAllMargins(bButtons, 6); - Button btnAddProfile = new Button("list-add-symbolic", IconSize.BUTTON); + Button btnAddProfile = Button.newFromIconName("list-add-symbolic", IconSize.Button); btnAddProfile.setTooltipText(_("Add profile")); - btnAddProfile.addOnClicked(&onAddProfile); + btnAddProfile.connectClicked(&onAddProfile); bButtons.packStart(btnAddProfile, false, false, 0); - - btnDeleteProfile = new Button("list-remove-symbolic", IconSize.BUTTON); + btnDeleteProfile = Button.newFromIconName("list-remove-symbolic", IconSize.Button); btnDeleteProfile.setTooltipText(_("Delete profile")); - btnDeleteProfile.addOnClicked(&onDeleteProfile); + btnDeleteProfile.connectClicked(&onDeleteProfile); bButtons.packStart(btnDeleteProfile, false, false, 0); - Box bSide = new Box(Orientation.VERTICAL, 0); + Box bSide = new Box(Orientation.Vertical, 0); bSide.add(sw); - bSide.add(new Separator(Orientation.HORIZONTAL)); + bSide.add(new Separator(Orientation.Horizontal)); bSide.add(bButtons); - Box box = new Box(Orientation.HORIZONTAL, 0); + Box box = new Box(Orientation.Horizontal, 0); box.add(bSide); - box.add(new Separator(Orientation.VERTICAL)); + box.add(new Separator(Orientation.Vertical)); box.add(pages); add(box); - SizeGroup sgSide = new SizeGroup(SizeGroupMode.HORIZONTAL); + SizeGroup sgSide = new SizeGroup(SizeGroupMode.Horizontal); sgSide.addWidget(hbSide); sgSide.addWidget(bSide); - SizeGroup sgMain = new SizeGroup(SizeGroupMode.HORIZONTAL); + SizeGroup sgMain = new SizeGroup(SizeGroupMode.Horizontal); sgMain.addWidget(hbMain); sgMain.addWidget(pages); @@ -251,7 +264,7 @@ private: hbMain.setTitle(""); searchButton = new ToggleButton(); - searchButton.setImage(new Image("system-search-symbolic", IconSize.MENU)); + searchButton.setImage(Image.newFromIconName("system-search-symbolic", IconSize.Menu)); searchButton.setNoShowAll(true); hbMain.packEnd(searchButton); @@ -262,27 +275,27 @@ private: hbSide.setShowCloseButton(true); hbSide.setTitle(_("Preferences")); - Box bTitle = new Box(Orientation.HORIZONTAL, 0); + Box bTitle = new Box(Orientation.Horizontal, 0); bTitle.add(hbSide); - Separator sTitle = new Separator(Orientation.VERTICAL); + Separator sTitle = new Separator(Orientation.Vertical); sTitle.getStyleContext().addClass("tilix-title-separator"); bTitle.add(sTitle); bTitle.add(hbMain); this.setTitlebar(bTitle); - this.addOnNotify(delegate(ParamSpec, ObjectG) { + this.connectNotify("gtk-decoration-layout", delegate(ParamSpec ps, ObjectWrap obj) { onDecorationLayout(); - }, "gtk-decoration-layout"); + }); onDecorationLayout(); } ListBoxRow createProfileTitleRow() { ListBoxRow row = new ListBoxRow(); - Box bProfileTitle = new Box(Orientation.VERTICAL, 2); - bProfileTitle.add(new Separator(Orientation.HORIZONTAL)); + Box bProfileTitle = new Box(Orientation.Vertical, 2); + bProfileTitle.add(new Separator(Orientation.Horizontal)); Label lblProfileTitle = new Label(format("%s",_("Profiles"))); lblProfileTitle.setUseMarkup(true); - lblProfileTitle.setHalign(GtkAlign.START); + lblProfileTitle.setHalign(Align.Start); lblProfileTitle.setSensitive(false); setAllMargins(row, 6); bProfileTitle.add(lblProfileTitle); @@ -331,7 +344,7 @@ private: } int getProfileRowCount() { - return lbSide.getChildren().length - nonProfileRowCount; + return cast(int)(lbSide.getChildren().length) - nonProfileRowCount; } // Stuff that deals with profiles @@ -386,7 +399,7 @@ private: void setDefaultProfile(ProfilePreferenceRow row) { prfMgr.setDefaultProfile(row.getProfile().uuid); - ProfilePreferenceRow[] rows = gx.gtk.util.getChildren!ProfilePreferenceRow(lbSide, false); + ProfilePreferenceRow[] rows = gx.gtk.util.findChildren!ProfilePreferenceRow(lbSide, false); foreach(r; rows) { if (r.uuid != row.uuid) { r.updateDefault(false); @@ -397,7 +410,7 @@ private: void updateDefaultProfileMarker() { string uuid = prfMgr.getDefaultProfile(); - ProfilePreferenceRow[] rows = gx.gtk.util.getChildren!ProfilePreferenceRow(lbSide, false); + ProfilePreferenceRow[] rows = gx.gtk.util.findChildren!ProfilePreferenceRow(lbSide, false); foreach(r; rows) { if (r.uuid != uuid) { r.updateDefault(false); @@ -412,7 +425,7 @@ public: this(ApplicationWindow window) { super(tilix); setTitle(_("Preferences")); - setTypeHint(WindowTypeHint.DIALOG); + setTypeHint(WindowTypeHint.Dialog); //setTransientFor(window); setDestroyWithParent(true); setShowMenubar(false); @@ -420,7 +433,7 @@ public: _wayland = isWayland(window); createUI(); updateUI(); - this.addOnDestroy(delegate(Widget) { + this.connectDestroy(delegate(Widget w) { trace("Preference window is destroyed"); pe.onProfileNameChanged.disconnect(&profileNameChanged); gsSettings.destroy(); @@ -429,9 +442,9 @@ public: // For some reason GTK doesn't propagate the destroy // signal to the ListBoxRow, have to explicitly remove // and destroy it. - this.addOnDelete(delegate(Event e, Widget) { + this.connectDeleteEvent(delegate(Event e, Widget w) { trace("Deleting list box rows"); - ListBoxRow[] rows = gx.gtk.util.getChildren!ListBoxRow(lbSide, false); + ListBoxRow[] rows = gx.gtk.util.findChildren!ListBoxRow(lbSide, false); foreach(row; rows) { lbSide.remove(row); row.destroy(); @@ -448,7 +461,7 @@ public: } void focusProfile(string uuid) { - ProfilePreferenceRow[] rows = gx.gtk.util.getChildren!ProfilePreferenceRow(lbSide, false); + ProfilePreferenceRow[] rows = gx.gtk.util.findChildren!ProfilePreferenceRow(lbSide, false); foreach(row; rows) { if (row.getProfile().uuid == uuid) { lbSide.selectRow(row); @@ -458,7 +471,7 @@ public: } void focusEncoding() { - GenericPreferenceRow[] rows = gx.gtk.util.getChildren!GenericPreferenceRow(lbSide, false); + GenericPreferenceRow[] rows = gx.gtk.util.findChildren!GenericPreferenceRow(lbSide, false); foreach(row; rows) { if (row.name() == N_("Encoding")) { lbSide.selectRow(row); @@ -480,12 +493,12 @@ public: _title = title; Label label = new Label(_(name)); - label.setHalign(GtkAlign.START); + label.setHalign(Align.Start); setAllMargins(label, 6); add(label); } - @property string name() { + @property override string name() { return _name; } @@ -511,21 +524,21 @@ private: immutable ACTION_PROFILE_DEFAULT = "default"; void createUI() { - Box box = new Box(Orientation.HORIZONTAL, 0); + Box box = new Box(Orientation.Horizontal, 0); setAllMargins(box, 6); lblName = new Label(profile.name); - lblName.setHalign(GtkAlign.START); + lblName.setHalign(Align.Start); box.packStart(lblName, true, true, 2); MenuButton btnMenu = new MenuButton(); - btnMenu.setRelief(ReliefStyle.NONE); + btnMenu.setRelief(ReliefStyle.None); btnMenu.setFocusOnClick(false); btnMenu.setPopover(createPopover(btnMenu)); box.packEnd(btnMenu, false, false, 0); - imgDefault = new Image("object-select-symbolic", IconSize.BUTTON); + imgDefault = Image.newFromIconName("object-select-symbolic", IconSize.Button); imgDefault.setNoShowAll(true); box.packEnd(imgDefault, false, false, 0); if (isDefault) { @@ -572,7 +585,7 @@ public: this.dialog = dialog; createActions(); createUI(); - addOnDestroy(delegate(Widget) { + connectDestroy(delegate(Widget w) { trace("ProfileRow destroyed"); dialog = null; sag.destroy(); @@ -601,7 +614,7 @@ public: return profile; } - @property string name() { + @property override string name() { return profile.name; } @@ -635,30 +648,34 @@ private: setMarginBottom(18); Label lblEncoding = new Label(_("Encodings showing in menu:")); - lblEncoding.setHalign(GtkAlign.START); + lblEncoding.setHalign(Align.Start); add(lblEncoding); + import gobject.value : Value; string[] menuEncodings = gsSettings.getStrv(SETTINGS_ENCODINGS_KEY); - ls = new ListStore([GType.BOOLEAN, GType.STRING, GType.STRING]); + ls = ListStore.new_([GTypes.BOOLEAN, GTypes.STRING, GTypes.STRING]); foreach (encoding; encodings) { - TreeIter iter = ls.createIter(); - ls.setValue(iter, 0, menuEncodings.canFind(encoding[0])); - ls.setValue(iter, 1, encoding[0] ~ " " ~ _(encoding[1])); - ls.setValue(iter, 2, encoding[0]); + TreeIter iter; + ls.append(iter); + ls.setValue(iter, 0, new Value(menuEncodings.canFind(encoding[0]))); + ls.setValue(iter, 1, new Value(encoding[0] ~ " " ~ _(encoding[1]))); + ls.setValue(iter, 2, new Value(encoding[0])); } - - TreeView tv = new TreeView(ls); + TreeView tv = new TreeView(); + tv.setModel(ls); tv.setHeadersVisible(false); CellRendererToggle toggle = new CellRendererToggle(); toggle.setActivatable(true); - toggle.addOnToggled(delegate(string path, CellRendererToggle) { + toggle.connectToggled(delegate(string path, CellRendererToggle crt) { TreeIter iter = new TreeIter(); - ls.getIter(iter, new TreePath(path)); - string encoding = ls.getValue(iter, COLUMN_ENCODING).getString(); - bool enabled = ls.getValue(iter, COLUMN_IS_ENABLED).getBoolean(); + ls.getIter(iter, TreePath.newFromString(path)); + Value valEncoding, valEnabled; + ls.getValue(iter, COLUMN_ENCODING, valEncoding); + ls.getValue(iter, COLUMN_IS_ENABLED, valEnabled); + string encoding = valEncoding.getString(); + bool enabled = valEnabled.getBoolean(); trace("Menu encoding clicked for " ~ encoding); - string[] encodingList = gsSettings.getStrv(SETTINGS_ENCODINGS_KEY); //Check for the reverse of what toggle is set for since //model is not updated until after settings updated @@ -674,17 +691,24 @@ private: } else { gsSettings.setStrv(SETTINGS_ENCODINGS_KEY, encodingList); } - ls.setValue(iter, COLUMN_IS_ENABLED, !enabled); + ls.setValue(iter, COLUMN_IS_ENABLED, new Value(!enabled)); }); - TreeViewColumn column = new TreeViewColumn(_("Enabled"), toggle, "active", COLUMN_IS_ENABLED); + TreeViewColumn column = new TreeViewColumn(); + column.setTitle(_("Enabled")); + column.packStart(toggle, true); + column.addAttribute(toggle, "active", COLUMN_IS_ENABLED); tv.appendColumn(column); - column = new TreeViewColumn(_("Encoding"), new CellRendererText(), "text", COLUMN_NAME); + CellRendererText crtEncoding = new CellRendererText(); + column = new TreeViewColumn(); + column.setTitle(_("Encoding")); + column.packStart(crtEncoding, true); + column.addAttribute(crtEncoding, "text", COLUMN_NAME); column.setExpand(true); tv.appendColumn(column); - - ScrolledWindow sw = new ScrolledWindow(tv); - sw.setShadowType(ShadowType.ETCHED_IN); - sw.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + ScrolledWindow sw = new ScrolledWindow(null, null); + sw.add(tv); + sw.setShadowType(ShadowType.EtchedIn); + sw.setPolicy(PolicyType.Never, PolicyType.Automatic); sw.setHexpand(true); sw.setVexpand(true); @@ -694,10 +718,10 @@ private: public: this(GSettings gsSettings) { - super(Orientation.VERTICAL, 6); + super(Orientation.Vertical, 6); this.gsSettings = gsSettings; createUI(); - this.addOnDestroy(delegate(Widget) { + this.connectDestroy(delegate(Widget w) { gsSettings = null; }); } @@ -739,7 +763,7 @@ private: setMarginBottom(18); rFind = new Revealer(); se = new SearchEntry(); - se.addOnSearchChanged(delegate(SearchEntry) { + se.connectSearchChanged(delegate(SearchEntry se) { filter.refilter(); tvShortcuts.expandAll(); }); @@ -748,89 +772,101 @@ private: add(rFind); //Shortcuts TreeView, note while detailed action name is in the model it's not actually displayed - tsShortcuts = new TreeStore([GType.STRING, GType.STRING, GType.STRING, GType.STRING]); + tsShortcuts = TreeStore.new_([GTypes.STRING, GTypes.STRING, GTypes.STRING, GTypes.STRING]); loadShortcuts(tsShortcuts); - filter = new TreeModelFilter(tsShortcuts, null); - filter.setVisibleFunc(cast(GtkTreeModelFilterVisibleFunc) &filterBookmark, cast(void*)this, null); + filter = cast(TreeModelFilter) tsShortcuts.filterNew(null); + filter.setVisibleFunc(delegate(TreeModel model, TreeIter iter) { + string name = tsShortcuts.getValueString(iter, COLUMN_NAME); + string text = se.getText(); + return (tsShortcuts.iterHasChild(iter) || text.length == 0 || name.indexOf(text, No.caseSensitive) >= 0); + }); - tvShortcuts = new TreeView(filter); + tvShortcuts = new TreeView(); + tvShortcuts.setModel(filter); tvShortcuts.setActivateOnSingleClick(false); - tvShortcuts.addOnCursorChanged(delegate(TreeView) { + tvShortcuts.connectCursorChanged(delegate(TreeView tv) { updateUI(); }); - bh.bind(SETTINGS_ACCELERATORS_ENABLED, tvShortcuts, "sensitive", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_ACCELERATORS_ENABLED, tvShortcuts, "sensitive", SettingsBindFlags.Default); - TreeViewColumn column = new TreeViewColumn(_("Action"), new CellRendererText(), "text", COLUMN_NAME); + CellRendererText crtAction = new CellRendererText(); + TreeViewColumn column = new TreeViewColumn(); + column.setTitle(_("Action")); + column.packStart(crtAction, true); + column.addAttribute(crtAction, "text", COLUMN_NAME); column.setExpand(true); tvShortcuts.appendColumn(column); - craShortcut = new CellRendererAccel(); craShortcut.setProperty("editable", 1); - craShortcut.setProperty("accel-mode", GtkCellRendererAccelMode.GTK); - craShortcut.addOnAccelCleared(delegate(string path, CellRendererAccel) { + craShortcut.setProperty("accel-mode", CellRendererAccelMode.Gtk); + craShortcut.connectAccelCleared(delegate(string path) { trace("Clearing shortcut"); TreeIter iter = new TreeIter(); - filter.getIter(iter, new TreePath(path)); + filter.getIter(iter, TreePath.newFromString(path)); filter.convertIterToChildIter(iter, iter); - tsShortcuts.setValue(iter, COLUMN_SHORTCUT, _(SHORTCUT_DISABLED)); + tsShortcuts.setValue(iter, COLUMN_SHORTCUT, new Value(_(SHORTCUT_DISABLED))); //Note accelerator changed by app which is monitoring gsetting changes updateShortcutSetting(iter, SHORTCUT_DISABLED); }); - craShortcut.addOnAccelEdited(delegate(string path, uint accelKey, GdkModifierType accelMods, uint, CellRendererAccel) { - string label = AccelGroup.acceleratorGetLabel(accelKey, accelMods); - string name = AccelGroup.acceleratorName(accelKey, accelMods); + craShortcut.connectAccelEdited(delegate(string path, uint accelKey, ModifierType accelMods, uint hardwareKeycode) { + string label = acceleratorGetLabel(accelKey, accelMods); + string accelName = acceleratorName(accelKey, accelMods); trace("Updating shortcut as " ~ label); TreeIter iter = new TreeIter(); - filter.getIter(iter, new TreePath(path)); - accelChanged(label, name, iter); + filter.getIter(iter, TreePath.newFromString(path)); + accelChanged(label, accelName, iter); }); - column = new TreeViewColumn(_("Shortcut Key"), craShortcut, "text", COLUMN_SHORTCUT); + column = new TreeViewColumn(); + column.setTitle(_("Shortcut Key")); + column.packStart(craShortcut, true); + column.addAttribute(craShortcut, "text", COLUMN_SHORTCUT); tvShortcuts.appendColumn(column); - ScrolledWindow scShortcuts = new ScrolledWindow(tvShortcuts); - scShortcuts.setShadowType(ShadowType.ETCHED_IN); - scShortcuts.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + ScrolledWindow scShortcuts = new ScrolledWindow(); + scShortcuts.add(tvShortcuts); + scShortcuts.setShadowType(ShadowType.EtchedIn); + scShortcuts.setPolicy(PolicyType.Never, PolicyType.Automatic); scShortcuts.setHexpand(true); scShortcuts.setVexpand(true); add(scShortcuts); - CheckButton cbAccelerators = new CheckButton(_("Enable shortcuts")); - bh.bind(SETTINGS_ACCELERATORS_ENABLED, cbAccelerators, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbAccelerators = CheckButton.newWithLabel(_("Enable shortcuts")); + bh.bind(SETTINGS_ACCELERATORS_ENABLED, cbAccelerators, "active", SettingsBindFlags.Default); - btnDefault = new Button("edit-undo-symbolic", IconSize.BUTTON); + btnDefault = Button.newFromIconName("edit-undo-symbolic", IconSize.Button); btnDefault.setTooltipText(_("Restore default shortcut for this action")); btnDefault.setSensitive(false); - btnDefault.addOnClicked(delegate(Button) { + btnDefault.connectClicked(delegate() { TreeIter iter = tvShortcuts.getSelectedIter(); if (iter is null) return; string action = filter.getValueString(iter, COLUMN_ACTION_NAME); size_t length; string defaultValue; if (filter.getValueString(iter, COLUMN_SHORTCUT_TYPE) == SC_TYPE_ACTION) { - defaultValue = gsShortcuts.getDefaultValue(action).getString(length); + defaultValue = gsShortcuts.getDefaultValue(action).getString(); } else { defaultValue = SHORTCUT_DISABLED; } filter.convertIterToChildIter(iter, iter); if (defaultValue == SHORTCUT_DISABLED) { - tsShortcuts.setValue(iter, COLUMN_SHORTCUT, _(SHORTCUT_DISABLED)); + tsShortcuts.setValue(iter, COLUMN_SHORTCUT, new Value(_(SHORTCUT_DISABLED))); updateShortcutSetting(iter, SHORTCUT_DISABLED); } else if (checkAndPromptChangeShortcut(action, defaultValue)) { //gsShortcuts.setString(action, defaultValue); updateShortcutSetting(iter, defaultValue); uint key; ModifierType mods; - AccelGroup.acceleratorParse(defaultValue, key, mods); - string label = AccelGroup.acceleratorGetLabel(key, mods); - tsShortcuts.setValue(iter, COLUMN_SHORTCUT, label); + acceleratorParse(defaultValue, key, mods); + string label = acceleratorGetLabel(key, mods); + tsShortcuts.setValue(iter, COLUMN_SHORTCUT, new Value(label)); } }); - Box box = new Box(Orientation.HORIZONTAL, 0); + Box box = new Box(Orientation.Horizontal, 0); box.packStart(btnDefault, false, false, 0); box.packEnd(cbAccelerators, false, false, 0); @@ -841,7 +877,7 @@ private: void updateUI() { TreeIter selected = tvShortcuts.getSelectedIter(); - btnDefault.setSensitive(selected !is null && selected.getParent() !is null); + btnDefault.setSensitive(selected !is null && hasParent(tsShortcuts, selected)); } /** @@ -872,7 +908,7 @@ private: string action = filter.getValueString(iter, COLUMN_ACTION_NAME); if (checkAndPromptChangeShortcut(action, label)) { filter.convertIterToChildIter(iter, iter); - tsShortcuts.setValue(iter, COLUMN_SHORTCUT, label); + tsShortcuts.setValue(iter, COLUMN_SHORTCUT, new Value(label)); tracef("Setting action %s to shortcut %s", action, label); //Note accelerator changed by app which is monitoring gsetting changes updateShortcutSetting(iter, name); @@ -909,24 +945,33 @@ private: if (tsShortcuts.getValueString(iter, COLUMN_SHORTCUT) == accelLabel) { trace("Checking toplevel"); Window window = cast(Window) this.getToplevel(); - MessageDialog dlg = new MessageDialog(window, DialogFlags.MODAL, MessageType.QUESTION, ButtonsType.OK_CANCEL, null, null); + GtkWidget* widget = gtk_message_dialog_new( + window ? cast(GtkWindow*) window._cPtr(No.Dup) : null, + DialogFlags.Modal, + MessageType.Question, + ButtonsType.OkCancel, + null, + null + ); + MessageDialog dlg = ObjectWrap._getDObject!MessageDialog(cast(void*) widget, No.Take); scope (exit) { dlg.destroy(); } string title = "" ~ _("Overwrite Existing Shortcut") ~ ""; string msg = format(_("The shortcut %s is already assigned to %s.\nDisable the shortcut for the other action and assign here instead?"), accelLabel, tsShortcuts.getValueString(iter, COLUMN_NAME)); - with (dlg) { - if (window !is null) setTransientFor(window); - setMarkup(title); - getMessageArea().setMarginLeft(0); - getMessageArea().setMarginRight(0); - getMessageArea().add(new Label(msg)); - setImage(new Image("dialog-question", IconSize.DIALOG)); - dlg.setDefaultResponse(ResponseType.OK); - showAll(); + if (window !is null) dlg.setTransientFor(window); + dlg.setMarkup(title); + Box msgArea = cast(Box) dlg.getMessageArea(); + if (msgArea !is null) { + msgArea.setMarginLeft(0); + msgArea.setMarginRight(0); + msgArea.add(new Label(msg)); } - if (dlg.run() != ResponseType.CANCEL) { - tsShortcuts.setValue(iter, COLUMN_SHORTCUT, _(SHORTCUT_DISABLED)); + dlg.setImage(Image.newFromIconName("dialog-question", IconSize.Dialog)); + dlg.setDefaultResponse(ResponseType.Ok); + dlg.showAll(); + if (dlg.run() != ResponseType.Cancel) { + tsShortcuts.setValue(iter, COLUMN_SHORTCUT, new Value(_(SHORTCUT_DISABLED))); updateShortcutSetting(iter, SHORTCUT_DISABLED); //gsShortcuts.setString(currentActionName, SHORTCUT_DISABLED); return true; @@ -947,7 +992,7 @@ private: * pre GTK 3.20 */ void loadLocalizedShortcutLabels() { - import glib.SimpleXML : SimpleXML; + import gx.glib.simplexml : SimpleXML; import glib.c.types : GMarkupParser, GMarkupParseContext, GMarkupParseFlags; import std.string : fromStringz; import std.array : empty; @@ -967,23 +1012,23 @@ private: GMarkupParser parseConfig; parseConfig.startElement = function void(GMarkupParseContext* context, const(char)* elementNameC, - char** attributeNames, - char** attributeValues, + const(char*)* attributeNames, + const(char*)* attributeValues, void* userData, GError** err) { auto helper = cast(ParseHelper*)userData; const elementName = elementNameC.fromStringz; if (elementName == "object") { string[string] attrs; - for (uint i = 0; attributeNames[i] != null; i++) - attrs[attributeNames[i].fromStringz.to!string] = attributeValues[i].fromStringz.to!string; + for (uint i = 0; attributeNames[i] !is null; i++) + attrs[(cast(const(char)*)attributeNames[i]).fromStringz.idup] = (cast(const(char)*)attributeValues[i]).fromStringz.idup; if (attrs.get("class", "") == "GtkShortcutsShortcut") helper.currentId = attrs["id"]; } else if (elementName == "property" && !helper.currentId.empty) { - for (uint i = 0; attributeNames[i] != null; i++) { - if (attributeNames[i].fromStringz == "name" && attributeValues[i].fromStringz == "title") { + for (uint i = 0; attributeNames[i] !is null; i++) { + if ((cast(const(char)*)attributeNames[i]).fromStringz == "name" && (cast(const(char)*)attributeValues[i]).fromStringz == "title") { helper.addNextText = true; break; } @@ -1006,7 +1051,7 @@ private: try { ParseHelper helper; - auto parser = new SimpleXML(&parseConfig, GMarkupParseFlags.PREFIX_ERROR_POSITION, &helper, null); + auto parser = new SimpleXML(&parseConfig, GMarkupParseFlags.PrefixErrorPosition, &helper, null); parser.parse(ui, ui.length); labels = helper.labels; @@ -1093,7 +1138,7 @@ private: // Check if shortcut supported in current GTK Version if (key in gtkVersioned) { int[2] gtkVersion = gtkVersioned[key]; - if (Version.checkVersion(gtkVersion[0], gtkVersion[1], 0).length > 0) continue; + if (checkVersion(gtkVersion[0], gtkVersion[1], 0).length > 0) continue; } // Check if shortcut supported in current VTE Version if (key in vteVersioned) { @@ -1122,23 +1167,17 @@ private: } } - static extern(C) int filterBookmark(GtkTreeModel* gtkModel, GtkTreeIter* gtkIter, ShortcutPreferences page) { - TreeIter iter = ObjectG.getDObject!(TreeIter)(gtkIter, true); - string name = page.tsShortcuts.getValueString(iter, COLUMN_NAME); - //import std.string: No; - string text = page.se.getText(); - return (page.tsShortcuts.iterHasChild(iter) || text.length==0 || name.indexOf(text, No.caseSensitive) >= 0); - } + // filterBookmark function removed - now using inline delegate in setVisibleFunc public: this(GSettings gsSettings) { - super(Orientation.VERTICAL, 6); + super(Orientation.Vertical, 6); this.gsSettings = gsSettings; bh = new BindingHelper(gsSettings); gsShortcuts = new GSettings(SETTINGS_KEY_BINDINGS_ID); createUI(); - this.addOnDestroy(delegate(Widget) { + this.connectDestroy(delegate(Widget w) { bh.unbind(); bh = null; gsSettings = null; @@ -1170,13 +1209,13 @@ class AppearancePreferences: Box { //Window style grid.attach(createLabel(_("Window style")), 0, row, 1, 1); - Box bWindowStyle = new Box(Orientation.HORIZONTAL, 6); + Box bWindowStyle = new Box(Orientation.Horizontal, 6); ComboBox cbWindowStyle = createNameValueCombo([_("Normal"), _("Disable CSD"), _("Disable CSD, hide toolbar"), _("Borderless")], SETTINGS_WINDOW_STYLE_VALUES); - bh.bind(SETTINGS_WINDOW_STYLE_KEY, cbWindowStyle, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_WINDOW_STYLE_KEY, cbWindowStyle, "active-id", SettingsBindFlags.Default); bWindowStyle.add(cbWindowStyle); Label lblRestart = new Label(_("Window restart required")); - lblRestart.setHalign(GtkAlign.START); + lblRestart.setHalign(Align.Start); lblRestart.setSensitive(false); bWindowStyle.add(lblRestart); @@ -1186,27 +1225,27 @@ class AppearancePreferences: Box { //Render terminal titlebars smaller then default grid.attach(createLabel(_("Terminal title style")), 0, row, 1, 1); ComboBox cbTitleStyle = createNameValueCombo([_("Normal"), _("Small"), _("None")], SETTINGS_TERMINAL_TITLE_STYLE_VALUES); - bh.bind(SETTINGS_TERMINAL_TITLE_STYLE_KEY, cbTitleStyle, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_TERMINAL_TITLE_STYLE_KEY, cbTitleStyle, "active-id", SettingsBindFlags.Default); grid.attach(cbTitleStyle, 1, row, 1, 1); row++; grid.attach(createLabel(_("Tab position")), 0, row, 1, 1); ComboBox cbTabPosition = createNameValueCombo([_("Left"), _("Right"), _("Top"), _("Bottom")], SETTINGS_TAB_POSITION_VALUES); - bh.bind(SETTINGS_TAB_POSITION_KEY, cbTabPosition, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_TAB_POSITION_KEY, cbTabPosition, "active-id", SettingsBindFlags.Default); grid.attach(cbTabPosition, 1, row, 1, 1); row++; //Dark Theme grid.attach(createLabel(_("Theme variant")), 0, row, 1, 1); ComboBox cbThemeVariant = createNameValueCombo([_("Default"), _("Light"), _("Dark")], SETTINGS_THEME_VARIANT_VALUES); - bh.bind(SETTINGS_THEME_VARIANT_KEY, cbThemeVariant, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_THEME_VARIANT_KEY, cbThemeVariant, "active-id", SettingsBindFlags.Default); grid.attach(cbThemeVariant, 1, row, 1, 1); row++; //Background Image grid.attach(createLabel(_("Background image")), 0, row, 1, 1); - FileChooserButton fcbImage = new FileChooserButton(_("Select Image"), FileChooserAction.OPEN); + FileChooserButton fcbImage = new FileChooserButton(_("Select Image"), FileChooserAction.Open); fcbImage.setHexpand(true); FileFilter ff = new FileFilter(); ff.setName(_("All Image Files")); @@ -1222,33 +1261,33 @@ class AppearancePreferences: Box { if (exists(filename)) { fcbImage.setFilename(filename); } - fcbImage.addOnFileSet(delegate(FileChooserButton fcb) { + fcbImage.connectFileSet(delegate(FileChooserButton fcb) { string selectedFilename = fcb.getFilename(); if (exists(selectedFilename)) { gsSettings.setString(SETTINGS_BACKGROUND_IMAGE_KEY, selectedFilename); } }); - Button btnReset = new Button("edit-delete-symbolic", IconSize.BUTTON); + Button btnReset = Button.newFromIconName("edit-delete-symbolic", IconSize.Button); btnReset.setTooltipText(_("Reset background image")); - btnReset.addOnClicked(delegate(Button) { + btnReset.connectClicked(delegate() { fcbImage.unselectAll(); gsSettings.reset(SETTINGS_BACKGROUND_IMAGE_KEY); }); ComboBox cbImageMode = createNameValueCombo([_("Scale"), _("Tile"), _("Center"),_("Stretch")], SETTINGS_BACKGROUND_IMAGE_MODE_VALUES); - bh.bind(SETTINGS_BACKGROUND_IMAGE_MODE_KEY, cbImageMode, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_BACKGROUND_IMAGE_MODE_KEY, cbImageMode, "active-id", SettingsBindFlags.Default); // Background image settings only enabled if transparency is enabled - bh.bind(SETTINGS_ENABLE_TRANSPARENCY_KEY, fcbImage, "sensitive", GSettingsBindFlags.DEFAULT); - bh.bind(SETTINGS_ENABLE_TRANSPARENCY_KEY, btnReset, "sensitive", GSettingsBindFlags.DEFAULT); - bh.bind(SETTINGS_ENABLE_TRANSPARENCY_KEY, cbImageMode, "sensitive", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_ENABLE_TRANSPARENCY_KEY, fcbImage, "sensitive", SettingsBindFlags.Default); + bh.bind(SETTINGS_ENABLE_TRANSPARENCY_KEY, btnReset, "sensitive", SettingsBindFlags.Default); + bh.bind(SETTINGS_ENABLE_TRANSPARENCY_KEY, cbImageMode, "sensitive", SettingsBindFlags.Default); - Box bChooser = new Box(Orientation.HORIZONTAL, 2); + Box bChooser = new Box(Orientation.Horizontal, 2); bChooser.add(fcbImage); bChooser.add(btnReset); - Box bImage = new Box(Orientation.HORIZONTAL, 6); + Box bImage = new Box(Orientation.Horizontal, 6); bImage.add(bChooser); bImage.add(cbImageMode); grid.attach(bImage, 1, row, 1, 1); @@ -1256,13 +1295,13 @@ class AppearancePreferences: Box { //Session Name Label lblSessionName = new Label(_("Default session name")); - lblSessionName.setHalign(GtkAlign.END); + lblSessionName.setHalign(Align.End); grid.attach(lblSessionName, 0, row, 1, 1); Entry eSessionName = new Entry(); eSessionName.setHexpand(true); - bh.bind(SETTINGS_SESSION_NAME_KEY, eSessionName, "text", GSettingsBindFlags.DEFAULT); - if (Version.checkVersion(3, 16, 0).length == 0) { + bh.bind(SETTINGS_SESSION_NAME_KEY, eSessionName, "text", SettingsBindFlags.Default); + if (checkVersion(3, 16, 0).length == 0) { grid.attach(createTitleEditHelper(eSessionName, TitleEditScope.SESSION), 1, row, 1, 1); } else { grid.attach(eSessionName, 1, row, 1, 1); @@ -1271,13 +1310,13 @@ class AppearancePreferences: Box { //Application Title Label lblAppTitle = new Label(_("Application title")); - lblAppTitle.setHalign(GtkAlign.END); + lblAppTitle.setHalign(Align.End); grid.attach(lblAppTitle, 0, row, 1, 1); Entry eAppTitle = new Entry(); eAppTitle.setHexpand(true); - bh.bind(SETTINGS_APP_TITLE_KEY, eAppTitle, "text", GSettingsBindFlags.DEFAULT); - if (Version.checkVersion(3, 16, 0).length == 0) { + bh.bind(SETTINGS_APP_TITLE_KEY, eAppTitle, "text", SettingsBindFlags.Default); + if (checkVersion(3, 16, 0).length == 0) { grid.attach(createTitleEditHelper(eAppTitle, TitleEditScope.WINDOW), 1, row, 1, 1); } else { grid.attach(eAppTitle, 1, row, 1, 1); @@ -1287,45 +1326,45 @@ class AppearancePreferences: Box { add(grid); //Enable Transparency, only enabled if less then 3.18 - if (Version.getMajorVersion() <= 3 && Version.getMinorVersion() < 18) { - CheckButton cbTransparent = new CheckButton(_("Enable transparency, requires re-start")); - bh.bind(SETTINGS_ENABLE_TRANSPARENCY_KEY, cbTransparent, "active", GSettingsBindFlags.DEFAULT); + if (getMajorVersion() <= 3 && getMinorVersion() < 18) { + CheckButton cbTransparent = CheckButton.newWithLabel(_("Enable transparency, requires re-start")); + bh.bind(SETTINGS_ENABLE_TRANSPARENCY_KEY, cbTransparent, "active", SettingsBindFlags.Default); add(cbTransparent); } - if (Version.checkVersion(3, 16, 0).length == 0) { - CheckButton cbWideHandle = new CheckButton(_("Use a wide handle for splitters")); - bh.bind(SETTINGS_ENABLE_WIDE_HANDLE_KEY, cbWideHandle, "active", GSettingsBindFlags.DEFAULT); + if (checkVersion(3, 16, 0).length == 0) { + CheckButton cbWideHandle = CheckButton.newWithLabel(_("Use a wide handle for splitters")); + bh.bind(SETTINGS_ENABLE_WIDE_HANDLE_KEY, cbWideHandle, "active", SettingsBindFlags.Default); add(cbWideHandle); } - CheckButton cbRightSidebar = new CheckButton(_("Place the sidebar on the right")); - bh.bind(SETTINGS_SIDEBAR_RIGHT, cbRightSidebar, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbRightSidebar = CheckButton.newWithLabel(_("Place the sidebar on the right")); + bh.bind(SETTINGS_SIDEBAR_RIGHT, cbRightSidebar, "active", SettingsBindFlags.Default); add(cbRightSidebar); - CheckButton cbTitleShowWhenSingle = new CheckButton(_("Show the terminal title even if it's the only terminal")); - bh.bind(SETTINGS_TERMINAL_TITLE_SHOW_WHEN_SINGLE_KEY, cbTitleShowWhenSingle, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbTitleShowWhenSingle = CheckButton.newWithLabel(_("Show the terminal title even if it's the only terminal")); + bh.bind(SETTINGS_TERMINAL_TITLE_SHOW_WHEN_SINGLE_KEY, cbTitleShowWhenSingle, "active", SettingsBindFlags.Default); add(cbTitleShowWhenSingle); - if (Version.checkVersion(3, GTK_SCROLLEDWINDOW_VERSION, 0).length == 0 && environment.get("GTK_OVERLAY_SCROLLING","1") == "1") { - CheckButton cbOverlay = new CheckButton(_("Use overlay scrollbars (Application restart required)")); - bh.bind(SETTINGS_USE_OVERLAY_SCROLLBAR_KEY, cbOverlay, "active", GSettingsBindFlags.DEFAULT); + if (checkVersion(3, GTK_SCROLLEDWINDOW_VERSION, 0).length == 0 && environment.get("GTK_OVERLAY_SCROLLING","1") == "1") { + CheckButton cbOverlay = CheckButton.newWithLabel(_("Use overlay scrollbars (Application restart required)")); + bh.bind(SETTINGS_USE_OVERLAY_SCROLLBAR_KEY, cbOverlay, "active", SettingsBindFlags.Default); add(cbOverlay); } - CheckButton cbUseTabs = new CheckButton(_("Use tabs instead of sidebar (Application restart required)")); - bh.bind(SETTINGS_USE_TABS_KEY, cbUseTabs, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbUseTabs = CheckButton.newWithLabel(_("Use tabs instead of sidebar (Application restart required)")); + bh.bind(SETTINGS_USE_TABS_KEY, cbUseTabs, "active", SettingsBindFlags.Default); add(cbUseTabs); } public: this(GSettings gsSettings) { - super(Orientation.VERTICAL, 6); + super(Orientation.Vertical, 6); this.gsSettings = gsSettings; bh = new BindingHelper(gsSettings); createUI(); - addOnDestroy(delegate(Widget) { + connectDestroy(delegate(Widget w) { bh.unbind(); bh = null; @@ -1347,7 +1386,7 @@ private: Label lblSize = new Label(format("%s", _("Size"))); lblSize.setUseMarkup(true); - lblSize.setHalign(GtkAlign.START); + lblSize.setHalign(Align.Start); add(lblSize); Grid grid = new Grid(); @@ -1357,43 +1396,43 @@ private: // Terminal Height grid.attach(createLabel(_("Height percent")), 0, row, 1, 1); - Scale sHeight = new Scale(Orientation.HORIZONTAL, 10, 90, 10); - sHeight.setValuePos(GtkPositionType.RIGHT); + Scale sHeight = Scale.newWithRange(Orientation.Horizontal, 10, 90, 10); + sHeight.setValuePos(PositionType.Right); sHeight.setHexpand(true); - sHeight.setHalign(GtkAlign.FILL); - bh.bind(SETTINGS_QUAKE_HEIGHT_PERCENT_KEY, sHeight.getAdjustment(), "value", GSettingsBindFlags.DEFAULT); + sHeight.setHalign(Align.Fill); + bh.bind(SETTINGS_QUAKE_HEIGHT_PERCENT_KEY, sHeight.getAdjustment(), "value", SettingsBindFlags.Default); grid.attach(sHeight, 1, row, 1, 1); row++; if (!wayland) { // Terminal Width grid.attach(createLabel(_("Width percent")), 0, row, 1, 1); - Scale sWidth = new Scale(Orientation.HORIZONTAL, 10, 100, 10); - sWidth.setValuePos(GtkPositionType.RIGHT); + Scale sWidth = Scale.newWithRange(Orientation.Horizontal, 10, 100, 10); + sWidth.setValuePos(PositionType.Right); sWidth.setHexpand(true); - sWidth.setHalign(GtkAlign.FILL); - bh.bind(SETTINGS_QUAKE_WIDTH_PERCENT_KEY, sWidth.getAdjustment(), "value", GSettingsBindFlags.DEFAULT); + sWidth.setHalign(Align.Fill); + bh.bind(SETTINGS_QUAKE_WIDTH_PERCENT_KEY, sWidth.getAdjustment(), "value", SettingsBindFlags.Default); grid.attach(sWidth, 1, row, 1, 1); row++; //Alignment grid.attach(createLabel(_("Alignment")), 0, row, 1, 1); ComboBox cbAlignment = createNameValueCombo([_("Left"), _("Center"), _("Right")], [SETTINGS_QUAKE_ALIGNMENT_LEFT_VALUE, SETTINGS_QUAKE_ALIGNMENT_CENTER_VALUE, SETTINGS_QUAKE_ALIGNMENT_RIGHT_VALUE]); - bh.bind(SETTINGS_QUAKE_ALIGNMENT_KEY, cbAlignment, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_QUAKE_ALIGNMENT_KEY, cbAlignment, "active-id", SettingsBindFlags.Default); grid.attach(cbAlignment, 1, row, 1, 1); row++; } grid.attach(createLabel(_("Tab position")), 0, row, 1, 1); ComboBox cbTabPosition = createNameValueCombo([_("Left"), _("Right"), _("Top"), _("Bottom")], SETTINGS_TAB_POSITION_VALUES); - bh.bind(SETTINGS_QUAKE_TAB_POSITION_KEY, cbTabPosition, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_QUAKE_TAB_POSITION_KEY, cbTabPosition, "active-id", SettingsBindFlags.Default); grid.attach(cbTabPosition, 1, row, 1, 1); row++; if (!wayland) { grid.attach(createLabel(_("Window position")), 0, row, 1, 1); ComboBox cbWinPosition = createNameValueCombo([_("Top"), _("Bottom")], SETTINGS_QUAKE_WINDOW_POSITION_VALUES); - bh.bind(SETTINGS_QUAKE_WINDOW_POSITION_KEY, cbWinPosition, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_QUAKE_WINDOW_POSITION_KEY, cbWinPosition, "active-id", SettingsBindFlags.Default); grid.attach(cbWinPosition, 1, row, 1, 1); row++; } @@ -1402,49 +1441,49 @@ private: Label lblOptions = new Label(format("%s", _("Options"))); lblOptions.setUseMarkup(true); - lblOptions.setHalign(GtkAlign.START); + lblOptions.setHalign(Align.Start); add(lblOptions); - Box bContent = new Box(Orientation.VERTICAL, 6); + Box bContent = new Box(Orientation.Vertical, 6); //Show on all workspaces - CheckButton cbAllWorkspaces = new CheckButton(_("Show terminal on all workspaces")); - bh.bind(SETTINGS_QUAKE_SHOW_ON_ALL_WORKSPACES_KEY, cbAllWorkspaces, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbAllWorkspaces = CheckButton.newWithLabel(_("Show terminal on all workspaces")); + bh.bind(SETTINGS_QUAKE_SHOW_ON_ALL_WORKSPACES_KEY, cbAllWorkspaces, "active", SettingsBindFlags.Default); bContent.add(cbAllWorkspaces); //Disable animations /* - CheckButton cbDisableAnimations = new CheckButton(_("Set hint for window manager to disable animation")); - bh.bind(SETTINGS_QUAKE_DISABLE_ANIMATION_KEY, cbDisableAnimations, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbDisableAnimations = CheckButton.newWithLabel(_("Set hint for window manager to disable animation")); + bh.bind(SETTINGS_QUAKE_DISABLE_ANIMATION_KEY, cbDisableAnimations, "active", SettingsBindFlags.Default); bContent.add(cbDisableAnimations); */ //Hide window on lose focus, note issue #858 - CheckButton cbHideOnLoseFocus = new CheckButton(_("Hide window when focus is lost")); - bh.bind(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_KEY, cbHideOnLoseFocus, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbHideOnLoseFocus = CheckButton.newWithLabel(_("Hide window when focus is lost")); + bh.bind(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_KEY, cbHideOnLoseFocus, "active", SettingsBindFlags.Default); bContent.add(cbHideOnLoseFocus); Label lblDelay = new Label(_("Delay hiding window by (ms)")); - SpinButton sbDelay = new SpinButton(50, 1000, 50); - bh.bind(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_DELAY_KEY, sbDelay, "value", GSettingsBindFlags.DEFAULT); - bh.bind(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_KEY, sbDelay, "sensitive", GSettingsBindFlags.DEFAULT); - bh.bind(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_KEY, lblDelay, "sensitive", GSettingsBindFlags.DEFAULT); + SpinButton sbDelay = SpinButton.newWithRange(50, 1000, 50); + bh.bind(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_DELAY_KEY, sbDelay, "value", SettingsBindFlags.Default); + bh.bind(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_KEY, sbDelay, "sensitive", SettingsBindFlags.Default); + bh.bind(SETTINGS_QUAKE_HIDE_LOSE_FOCUS_KEY, lblDelay, "sensitive", SettingsBindFlags.Default); - Box bDelay = new Box(Orientation.HORIZONTAL, 6); + Box bDelay = new Box(Orientation.Horizontal, 6); bDelay.add(lblDelay); bDelay.add(sbDelay); bDelay.setMarginLeft(48); bContent.add(bDelay); //Hide headerbar - CheckButton cbHideHeaderbar = new CheckButton(_("Hide the toolbar of the window")); - bh.bind(SETTINGS_QUAKE_HIDE_HEADERBAR_KEY, cbHideHeaderbar, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbHideHeaderbar = CheckButton.newWithLabel(_("Hide the toolbar of the window")); + bh.bind(SETTINGS_QUAKE_HIDE_HEADERBAR_KEY, cbHideHeaderbar, "active", SettingsBindFlags.Default); bContent.add(cbHideHeaderbar); /* //Keep window on top - CheckButton cbKeepOnTop = new CheckButton(_("Always keep window on top")); - bh.bind(SETTINGS_QUAKE_KEEP_ON_TOP_KEY, cbKeepOnTop, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbKeepOnTop = CheckButton.newWithLabel(_("Always keep window on top")); + bh.bind(SETTINGS_QUAKE_KEEP_ON_TOP_KEY, cbKeepOnTop, "active", SettingsBindFlags.Default); bContent.add(cbKeepOnTop); */ @@ -1452,20 +1491,20 @@ private: if (!wayland) { //Always on top - CheckButton cbKeepOnTop = new CheckButton(_("Keep window always on top")); - bh.bind(SETTINGS_QUAKE_KEEP_ON_TOP_KEY, cbKeepOnTop, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbKeepOnTop = CheckButton.newWithLabel(_("Keep window always on top")); + bh.bind(SETTINGS_QUAKE_KEEP_ON_TOP_KEY, cbKeepOnTop, "active", SettingsBindFlags.Default); bContent.add(cbKeepOnTop); //Active Monitor - CheckButton cbActiveMonitor = new CheckButton(_("Display terminal on active monitor")); - bh.bind(SETTINGS_QUAKE_ACTIVE_MONITOR_KEY, cbActiveMonitor, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbActiveMonitor = CheckButton.newWithLabel(_("Display terminal on active monitor")); + bh.bind(SETTINGS_QUAKE_ACTIVE_MONITOR_KEY, cbActiveMonitor, "active", SettingsBindFlags.Default); bContent.add(cbActiveMonitor); //Specific Monitor - Box bSpecific = new Box(Orientation.HORIZONTAL, 6); + Box bSpecific = new Box(Orientation.Horizontal, 6); bSpecific.setMarginLeft(36); Label lblSpecific = new Label(_("Display on specific monitor")); - bh.bind(SETTINGS_QUAKE_ACTIVE_MONITOR_KEY, lblSpecific, "sensitive", GSettingsBindFlags.INVERT_BOOLEAN); + bh.bind(SETTINGS_QUAKE_ACTIVE_MONITOR_KEY, lblSpecific, "sensitive", SettingsBindFlags.InvertBoolean); bSpecific.add(lblSpecific); string[] names = [_("Primary Monitor")]; int[] values = [-1]; @@ -1475,25 +1514,25 @@ private: } ComboBox cbScreen = TComboBox!(int).createComboBox(names, values); - cbScreen.addOnChanged(delegate(ComboBox cb) { + cbScreen.connectChanged(delegate(ComboBox cb) { TreeIter iter; if (cb.getActiveIter(iter)) { ListStore ls = cast(ListStore)cb.getModel(); - bh.settings.setInt(SETTINGS_QUAKE_SPECIFIC_MONITOR_KEY, ls.getValueInt(iter, 1)); + bh.settings.setInt(SETTINGS_QUAKE_SPECIFIC_MONITOR_KEY, getValueInt(ls, iter, 1)); } else { bh.settings.setInt(SETTINGS_QUAKE_SPECIFIC_MONITOR_KEY,-1); } }); int index = 0; foreach(TreeIter iter; TreeIterRange(cbScreen.getModel())) { - if (cbScreen.getModel().getValueInt(iter, 1) == bh.settings.getInt(SETTINGS_QUAKE_SPECIFIC_MONITOR_KEY)) { + if (getValueInt(cbScreen.getModel(), iter, 1) == bh.settings.getInt(SETTINGS_QUAKE_SPECIFIC_MONITOR_KEY)) { cbScreen.setActive(index); break; } index++; } - //bh.bind(SETTINGS_QUAKE_SPECIFIC_MONITOR_KEY, cbScreen, "active-id", GSettingsBindFlags.DEFAULT); - bh.bind(SETTINGS_QUAKE_ACTIVE_MONITOR_KEY, cbScreen, "sensitive", GSettingsBindFlags.INVERT_BOOLEAN); + //bh.bind(SETTINGS_QUAKE_SPECIFIC_MONITOR_KEY, cbScreen, "active-id", SettingsBindFlags.Default); + bh.bind(SETTINGS_QUAKE_ACTIVE_MONITOR_KEY, cbScreen, "sensitive", SettingsBindFlags.InvertBoolean); bSpecific.add(cbScreen); bContent.add(bSpecific); @@ -1505,10 +1544,10 @@ private: public: this(GSettings gsSettings, bool wayland) { - super(Orientation.VERTICAL, 6); + super(Orientation.Vertical, 6); bh = new BindingHelper(gsSettings); createUI(wayland); - addOnDestroy(delegate(Widget) { + connectDestroy(delegate(Widget w) { bh.unbind(); bh = null; }); @@ -1532,111 +1571,111 @@ private: Label lblBehavior = new Label(format("%s", _("Behavior"))); lblBehavior.setUseMarkup(true); - lblBehavior.setHalign(GtkAlign.START); + lblBehavior.setHalign(Align.Start); add(lblBehavior); //Prompt on new session - CheckButton cbPrompt = new CheckButton(_("Prompt when creating a new session")); - bh.bind(SETTINGS_PROMPT_ON_NEW_SESSION_KEY, cbPrompt, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbPrompt = CheckButton.newWithLabel(_("Prompt when creating a new session")); + bh.bind(SETTINGS_PROMPT_ON_NEW_SESSION_KEY, cbPrompt, "active", SettingsBindFlags.Default); add(cbPrompt); //Focus follows the mouse - CheckButton cbFocusMouse = new CheckButton(_("Focus a terminal when the mouse moves over it")); - bh.bind(SETTINGS_TERMINAL_FOCUS_FOLLOWS_MOUSE_KEY, cbFocusMouse, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbFocusMouse = CheckButton.newWithLabel(_("Focus a terminal when the mouse moves over it")); + bh.bind(SETTINGS_TERMINAL_FOCUS_FOLLOWS_MOUSE_KEY, cbFocusMouse, "active", SettingsBindFlags.Default); add(cbFocusMouse); //Auto hide the mouse - CheckButton cbAutoHideMouse = new CheckButton(_("Autohide the mouse pointer when typing")); - bh.bind(SETTINGS_AUTO_HIDE_MOUSE_KEY, cbAutoHideMouse, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbAutoHideMouse = CheckButton.newWithLabel(_("Autohide the mouse pointer when typing")); + bh.bind(SETTINGS_AUTO_HIDE_MOUSE_KEY, cbAutoHideMouse, "active", SettingsBindFlags.Default); add(cbAutoHideMouse); //middle click closes the terminal - CheckButton cbMiddleClickClose = new CheckButton(_("Close terminal by clicking middle mouse button on title")); - bh.bind(SETTINGS_MIDDLE_CLICK_CLOSE_KEY, cbMiddleClickClose, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbMiddleClickClose = CheckButton.newWithLabel(_("Close terminal by clicking middle mouse button on title")); + bh.bind(SETTINGS_MIDDLE_CLICK_CLOSE_KEY, cbMiddleClickClose, "active", SettingsBindFlags.Default); add(cbMiddleClickClose); //zoom in/out terminal with scroll wheel - CheckButton cbControlScrollZoom = new CheckButton(_("Zoom the terminal using and scroll wheel")); - bh.bind(SETTINGS_CONTROL_SCROLL_ZOOM_KEY, cbControlScrollZoom, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbControlScrollZoom = CheckButton.newWithLabel(_("Zoom the terminal using and scroll wheel")); + bh.bind(SETTINGS_CONTROL_SCROLL_ZOOM_KEY, cbControlScrollZoom, "active", SettingsBindFlags.Default); add(cbControlScrollZoom); //require control modifier when clicking title - CheckButton cbControlClickTitle = new CheckButton(_("Require the modifier to edit title on click")); - bh.bind(SETTINGS_CONTROL_CLICK_TITLE_KEY, cbControlClickTitle, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbControlClickTitle = CheckButton.newWithLabel(_("Require the modifier to edit title on click")); + bh.bind(SETTINGS_CONTROL_CLICK_TITLE_KEY, cbControlClickTitle, "active", SettingsBindFlags.Default); add(cbControlClickTitle); //Closing of last session closes window - CheckButton cbCloseWithLastSession = new CheckButton(_("Close window when last session is closed")); - bh.bind(SETTINGS_CLOSE_WITH_LAST_SESSION_KEY, cbCloseWithLastSession, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbCloseWithLastSession = CheckButton.newWithLabel(_("Close window when last session is closed")); + bh.bind(SETTINGS_CLOSE_WITH_LAST_SESSION_KEY, cbCloseWithLastSession, "active", SettingsBindFlags.Default); add(cbCloseWithLastSession); // Save window state (maximized, minimized, fullscreen) between invocations - CheckButton cbWindowSaveState = new CheckButton(_("Save and restore window state")); - bh.bind(SETTINGS_WINDOW_SAVE_STATE_KEY, cbWindowSaveState, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbWindowSaveState = CheckButton.newWithLabel(_("Save and restore window state")); + bh.bind(SETTINGS_WINDOW_SAVE_STATE_KEY, cbWindowSaveState, "active", SettingsBindFlags.Default); add(cbWindowSaveState); //always use regex when searching - CheckButton cbAlwaysUseRegex = new CheckButton(_("Always search using regular expressions")); - bh.bind(SETTINGS_ALWAYS_USE_REGEX_IN_SEARCH, cbAlwaysUseRegex, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbAlwaysUseRegex = CheckButton.newWithLabel(_("Always search using regular expressions")); + bh.bind(SETTINGS_ALWAYS_USE_REGEX_IN_SEARCH, cbAlwaysUseRegex, "active", SettingsBindFlags.Default); add(cbAlwaysUseRegex); //Show Notifications, only show option if notifications are supported if (checkVTEFeature(TerminalFeature.EVENT_NOTIFICATION)) { - CheckButton cbNotify = new CheckButton(_("Send desktop notification on process complete")); - bh.bind(SETTINGS_NOTIFY_ON_PROCESS_COMPLETE_KEY, cbNotify, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbNotify = CheckButton.newWithLabel(_("Send desktop notification on process complete")); + bh.bind(SETTINGS_NOTIFY_ON_PROCESS_COMPLETE_KEY, cbNotify, "active", SettingsBindFlags.Default); add(cbNotify); } //New Instance Options - Box bNewInstance = new Box(Orientation.HORIZONTAL, 6); + Box bNewInstance = new Box(Orientation.Horizontal, 6); Label lblNewInstance = new Label(_("On new instance")); - lblNewInstance.setHalign(GtkAlign.END); + lblNewInstance.setHalign(Align.End); bNewInstance.add(lblNewInstance); ComboBox cbNewInstance = createNameValueCombo([_("New Window"), _("New Session"), _("Split Right"), _("Split Down"), _("Focus Window")], SETTINGS_NEW_INSTANCE_MODE_VALUES); - bh.bind(SETTINGS_NEW_INSTANCE_MODE_KEY, cbNewInstance, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_NEW_INSTANCE_MODE_KEY, cbNewInstance, "active-id", SettingsBindFlags.Default); bNewInstance.add(cbNewInstance); add(bNewInstance); // *********** Clipboard Options Label lblClipboard = new Label(format("%s", _("Clipboard"))); lblClipboard.setUseMarkup(true); - lblClipboard.setHalign(GtkAlign.START); + lblClipboard.setHalign(Align.Start); add(lblClipboard); //Advacned paste is default - CheckButton cbAdvDefault = new CheckButton(_("Always use advanced paste dialog")); - bh.bind(SETTINGS_PASTE_ADVANCED_DEFAULT_KEY, cbAdvDefault, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbAdvDefault = CheckButton.newWithLabel(_("Always use advanced paste dialog")); + bh.bind(SETTINGS_PASTE_ADVANCED_DEFAULT_KEY, cbAdvDefault, "active", SettingsBindFlags.Default); add(cbAdvDefault); //Unsafe Paste Warning - CheckButton cbUnsafe = new CheckButton(_("Warn when attempting unsafe paste")); - bh.bind(SETTINGS_UNSAFE_PASTE_ALERT_KEY, cbUnsafe, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbUnsafe = CheckButton.newWithLabel(_("Warn when attempting unsafe paste")); + bh.bind(SETTINGS_UNSAFE_PASTE_ALERT_KEY, cbUnsafe, "active", SettingsBindFlags.Default); add(cbUnsafe); //Strip Paste - CheckButton cbStrip = new CheckButton(_("Strip first character of paste if comment or variable declaration")); - bh.bind(SETTINGS_STRIP_FIRST_COMMENT_CHAR_ON_PASTE_KEY, cbStrip, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbStrip = CheckButton.newWithLabel(_("Strip first character of paste if comment or variable declaration")); + bh.bind(SETTINGS_STRIP_FIRST_COMMENT_CHAR_ON_PASTE_KEY, cbStrip, "active", SettingsBindFlags.Default); add(cbStrip); //Strip trailing whitespace on paste - CheckButton cbStripTrailing = new CheckButton(_("Strip trailing whitespaces and linebreak characters on paste")); - bh.bind(SETTINGS_STRIP_TRAILING_WHITESPACE, cbStripTrailing, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbStripTrailing = CheckButton.newWithLabel(_("Strip trailing whitespaces and linebreak characters on paste")); + bh.bind(SETTINGS_STRIP_TRAILING_WHITESPACE, cbStripTrailing, "active", SettingsBindFlags.Default); add(cbStripTrailing); //Copy on Select - CheckButton cbCopyOnSelect = new CheckButton(_("Automatically copy text to clipboard when selecting")); - bh.bind(SETTINGS_COPY_ON_SELECT_KEY, cbCopyOnSelect, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbCopyOnSelect = CheckButton.newWithLabel(_("Automatically copy text to clipboard when selecting")); + bh.bind(SETTINGS_COPY_ON_SELECT_KEY, cbCopyOnSelect, "active", SettingsBindFlags.Default); add(cbCopyOnSelect); } public: this(GSettings gsSettings) { - super(Orientation.VERTICAL, 6); + super(Orientation.Vertical, 6); bh = new BindingHelper(gsSettings); createUI(); - addOnDestroy(delegate(Widget) { + connectDestroy(delegate(Widget w) { bh.unbind(); bh = null; }); @@ -1653,7 +1692,7 @@ private: void createUI() { setAllMargins(this, 18); Grid grid = new Grid(); - grid.setHalign(GtkAlign.FILL); + grid.setHalign(Align.Fill); grid.setColumnSpacing(12); grid.setRowSpacing(6); @@ -1670,7 +1709,7 @@ private: public: this(GSettings gsSettings) { - super(Orientation.VERTICAL, 6); + super(Orientation.Vertical, 6); this.gsSettings = gsSettings; createUI(); } @@ -1680,7 +1719,7 @@ public: // Function to create a right aligned label with appropriate margins private Label createLabel(string text) { Label label = new Label(text); - label.setHalign(GtkAlign.END); + label.setHalign(Align.End); //label.setMarginLeft(12); return label; } diff --git a/source/gx/tilix/prefeditor/profileeditor.d b/source/gx/tilix/prefeditor/profileeditor.d index b9ba48384..e331e836d 100644 --- a/source/gx/tilix/prefeditor/profileeditor.d +++ b/source/gx/tilix/prefeditor/profileeditor.d @@ -13,54 +13,61 @@ import std.format; import std.path; import std.string; -import gdk.Event; -import gdk.RGBA; - -import gio.Settings : GSettings = Settings; - -import glib.URI; -import glib.Util; - -import gtk.Application; -import gtk.ApplicationWindow; -import gtk.Box; -import gtk.Button; -import gtk.CellRendererText; -import gtk.CheckButton; -import gtk.ColorButton; -import gtk.ComboBox; -import gtk.ComboBoxText; -import gtk.Dialog; -import gtk.EditableIF; -import gtk.Entry; -import gtk.FileChooserDialog; -import gtk.FileFilter; -import gtk.FontButton; -import gtk.Grid; -import gtk.HeaderBar; -import gtk.Image; -import gtk.Label; -import gtk.ListStore; -import gtk.MenuButton; -import gtk.Notebook; -import gtk.Popover; -import gtk.Scale; -import gtk.ScrolledWindow; -import gtk.SizeGroup; -import gtk.SpinButton; -import gtk.Switch; -import gtk.TreeIter; -import gtk.TreePath; -import gtk.TreeView; -import gtk.TreeViewColumn; -import gtk.Version; -import gtk.Widget; -import gtk.Window; +import gdk.event; +import gdk.rgba; + +import gio.settings : GSettings = Settings; +import gio.types : SettingsBindFlags; + +import glib.uri; +import glib.c.types : glong; +import glib.global : getUserConfigDir; + +import gtk.adjustment; +import gtk.application; +import gtk.application_window; +import gtk.box; +import gtk.button; +import gtk.cell_renderer_text; +import gtk.check_button; +import gtk.color_button; +import gtk.combo_box; +import gtk.combo_box_text; +import gtk.dialog; +import gtk.editable : Editable; +import gtk.entry; +import gtk.file_chooser_dialog; +import gtk.file_filter; +import gtk.font_button; +import gtk.grid; +import gtk.header_bar; +import gtk.image; +import gtk.label; +import gtk.list_store; +import gtk.menu_button; +import gtk.notebook; +import gtk.popover; +import gtk.scale; +import gtk.scrolled_window; +import gtk.size_group; +import gtk.spin_button; +import gtk.switch_; +import gtk.tree_iter; +import gtk.tree_path; +import gtk.tree_view; +import gtk.tree_view_column; +import gtk.types : Align, FileChooserAction, IconSize, Orientation, PolicyType, ResponseType, ShadowType, SizeGroupMode; +import gtk.global : checkVersion; +import gtk.widget; +import gtk.window; + +import gobject.value : Value; import gx.gtk.color; import gx.gtk.dialog; import gx.gtk.settings; import gx.gtk.util; +import gx.gtk.util : GTypes; import gx.gtk.vte; import gx.i18n.l10n; @@ -94,15 +101,15 @@ private: nb.setHexpand(true); nb.setVexpand(true); nb.setShowBorder(false); - nb.appendPage(new GeneralPage(this), _("General")); - nb.appendPage(new CommandPage(), _("Command")); - nb.appendPage(new ColorPage(), _("Color")); - nb.appendPage(new ScrollPage(), _("Scrolling")); - nb.appendPage(new CompatibilityPage(), _("Compatibility")); + nb.appendPage(new GeneralPage(this), new Label(_("General"))); + nb.appendPage(new CommandPage(), new Label(_("Command"))); + nb.appendPage(new ColorPage(), new Label(_("Color"))); + nb.appendPage(new ScrollPage(), new Label(_("Scrolling"))); + nb.appendPage(new CompatibilityPage(), new Label(_("Compatibility"))); if (isVTEBackgroundDrawEnabled()) { - nb.appendPage(new BadgePage(), _("Badge")); + nb.appendPage(new BadgePage(), new Label(_("Badge"))); } - nb.appendPage(new AdvancedPage(), _("Advanced")); + nb.appendPage(new AdvancedPage(), new Label(_("Advanced"))); add(nb); } @@ -118,9 +125,9 @@ package: public: this() { - super(Orientation.VERTICAL, 0); + super(Orientation.Vertical, 0); createUI(); - addOnDestroy(delegate(Widget) { + connectDestroy(delegate() { //trace("ProfileEditor destroyed"); unbind(); }); @@ -179,7 +186,7 @@ private: public: this() { - super(Orientation.VERTICAL, 6); + super(Orientation.Vertical, 6); setAllMargins(this, 18); bh = new BindingHelper(); } @@ -215,36 +222,36 @@ protected: //Profile Name Label lblName = new Label(_("Profile name")); - lblName.setHalign(GtkAlign.END); + lblName.setHalign(Align.End); grid.attach(lblName, 0, row, 1, 1); Entry eName = new Entry(); // Catch and pass name changes up to preferences dialog // Generally it would be better to simply use the Settings onChanged - // trigger however these are being used transiently here and since GtkDialogFlags + // trigger however these are being used transiently here and since DialogFlags // doesn't provide a way to remove event handlers we will do it this instead. - eName.addOnChanged(delegate(EditableIF editable) { - Entry entry = cast(Entry)editable; - pe.triggerNameChanged(entry.getText()); - }, ConnectFlags.AFTER); + eName.connectChanged(delegate(Editable editable) { + // Use eName directly from closure - casting Editable to Entry doesn't work in GID + pe.triggerNameChanged(eName.getText()); + }); eName.setHexpand(true); - bh.bind(SETTINGS_PROFILE_VISIBLE_NAME_KEY, eName, "text", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_VISIBLE_NAME_KEY, eName, "text", SettingsBindFlags.Default); grid.attach(eName, 1, row, 1, 1); row++; //Profile ID lblId = new Label(""); - // lblId.setHalign(GtkAlign.START); + // lblId.setHalign(Align.Start); // lblId.setSensitive(false); // grid.attach(lblId, 1, row, 1, 1); // row++; //Terminal Title Label lblTerminalTitle = new Label(_("Terminal title")); - lblTerminalTitle.setHalign(GtkAlign.END); + lblTerminalTitle.setHalign(Align.End); grid.attach(lblTerminalTitle, 0, row, 1, 1); Entry eTerminalTitle = new Entry(); eTerminalTitle.setHexpand(true); - bh.bind(SETTINGS_PROFILE_TITLE_KEY, eTerminalTitle, "text", GSettingsBindFlags.DEFAULT); - if (Version.checkVersion(3, 16, 0).length == 0) { + bh.bind(SETTINGS_PROFILE_TITLE_KEY, eTerminalTitle, "text", SettingsBindFlags.Default); + if (checkVersion(3, 16, 0).length == 0) { grid.attach(createTitleEditHelper(eTerminalTitle, TitleEditScope.TERMINAL), 1, row, 1, 1); } else { grid.attach(eTerminalTitle, 1, row, 1, 1); @@ -253,24 +260,24 @@ protected: Label lblTextTitle = new Label(format("%s", _("Text Appearance"))); lblTextTitle.setUseMarkup(true); - lblTextTitle.setHalign(GtkAlign.START); + lblTextTitle.setHalign(Align.Start); lblTextTitle.setMarginTop(6); grid.attach(lblTextTitle, 0, row, 2, 1); row++; //Terminal Size Label lblSize = new Label(_("Terminal size")); - lblSize.setHalign(GtkAlign.END); + lblSize.setHalign(Align.End); grid.attach(lblSize, 0, row, 1, 1); - SpinButton sbColumn = new SpinButton(16, 511, 1); - bh.bind(SETTINGS_PROFILE_SIZE_COLUMNS_KEY, sbColumn, "value", GSettingsBindFlags.DEFAULT); - SpinButton sbRow = new SpinButton(4, 511, 1); - bh.bind(SETTINGS_PROFILE_SIZE_ROWS_KEY, sbRow, "value", GSettingsBindFlags.DEFAULT); + SpinButton sbColumn = SpinButton.newWithRange(16, 511, 1); + bh.bind(SETTINGS_PROFILE_SIZE_COLUMNS_KEY, sbColumn, "value", SettingsBindFlags.Default); + SpinButton sbRow = SpinButton.newWithRange(4, 511, 1); + bh.bind(SETTINGS_PROFILE_SIZE_ROWS_KEY, sbRow, "value", SettingsBindFlags.Default); - Box box = new Box(Orientation.HORIZONTAL, 5); + Box box = new Box(Orientation.Horizontal, 5); box.add(sbColumn); Label lblColumns = new Label(_("columns")); - if (Version.checkVersion(3, 16, 0).length == 0) { + if (checkVersion(3, 16, 0).length == 0) { lblColumns.setXalign(0.0); } lblColumns.setMarginRight(6); @@ -279,15 +286,15 @@ protected: box.add(sbRow); Label lblRows = new Label(_("rows")); - if (Version.checkVersion(3, 16, 0).length == 0) { + if (checkVersion(3, 16, 0).length == 0) { lblRows.setXalign(0.0); } lblRows.setMarginRight(6); lblRows.setSensitive(false); box.add(lblRows); - Button btnReset = new Button(_("Reset")); - btnReset.addOnClicked(delegate(Button) { + Button btnReset = Button.newWithLabel(_("Reset")); + btnReset.connectClicked(delegate() { gsProfile.reset(SETTINGS_PROFILE_SIZE_COLUMNS_KEY); gsProfile.reset(SETTINGS_PROFILE_SIZE_ROWS_KEY); @@ -299,17 +306,17 @@ protected: //Terminal Spacing if (checkVTEVersion(VTE_VERSION_CELL_SCALE)) { Label lblSpacing = new Label(_("Cell spacing")); - lblSpacing.setHalign(GtkAlign.END); + lblSpacing.setHalign(Align.End); grid.attach(lblSpacing, 0, row, 1, 1); - SpinButton sbWidthSpacing = new SpinButton(1.0, 2.0, 0.1); - bh.bind(SETTINGS_PROFILE_CELL_WIDTH_SCALE_KEY, sbWidthSpacing, "value", GSettingsBindFlags.DEFAULT); - SpinButton sbHeightSpacing = new SpinButton(1.0, 2.0, 0.1); - bh.bind(SETTINGS_PROFILE_CELL_HEIGHT_SCALE_KEY, sbHeightSpacing, "value", GSettingsBindFlags.DEFAULT); + SpinButton sbWidthSpacing = SpinButton.newWithRange(1.0, 2.0, 0.1); + bh.bind(SETTINGS_PROFILE_CELL_WIDTH_SCALE_KEY, sbWidthSpacing, "value", SettingsBindFlags.Default); + SpinButton sbHeightSpacing = SpinButton.newWithRange(1.0, 2.0, 0.1); + bh.bind(SETTINGS_PROFILE_CELL_HEIGHT_SCALE_KEY, sbHeightSpacing, "value", SettingsBindFlags.Default); - Box bSpacing = new Box(Orientation.HORIZONTAL, 5); + Box bSpacing = new Box(Orientation.Horizontal, 5); bSpacing.add(sbWidthSpacing); Label lblWidthSpacing = new Label(_("width")); - if (Version.checkVersion(3, 16, 0).length == 0) { + if (checkVersion(3, 16, 0).length == 0) { lblWidthSpacing.setXalign(0.0); } lblWidthSpacing.setMarginRight(6); @@ -318,15 +325,15 @@ protected: bSpacing.add(sbHeightSpacing); Label lblHeightSpacing = new Label(_("height")); - if (Version.checkVersion(3, 16, 0).length == 0) { + if (checkVersion(3, 16, 0).length == 0) { lblHeightSpacing.setXalign(0.0); } lblHeightSpacing.setMarginRight(6); lblHeightSpacing.setSensitive(false); bSpacing.add(lblHeightSpacing); - Button btnSpacingReset = new Button(_("Reset")); - btnSpacingReset.addOnClicked(delegate(Button) { + Button btnSpacingReset = Button.newWithLabel(_("Reset")); + btnSpacingReset.connectClicked(delegate() { gsProfile.reset(SETTINGS_PROFILE_CELL_WIDTH_SCALE_KEY); gsProfile.reset(SETTINGS_PROFILE_CELL_WIDTH_SCALE_KEY); }); @@ -334,21 +341,21 @@ protected: grid.attach(bSpacing, 1, row, 1, 1); row++; - SizeGroup sgWidth = new SizeGroup(SizeGroupMode.HORIZONTAL); + SizeGroup sgWidth = new SizeGroup(SizeGroupMode.Horizontal); sgWidth.addWidget(lblColumns); sgWidth.addWidget(lblWidthSpacing); - SizeGroup sgHeight = new SizeGroup(SizeGroupMode.HORIZONTAL); + SizeGroup sgHeight = new SizeGroup(SizeGroupMode.Horizontal); sgHeight.addWidget(lblRows); sgHeight.addWidget(lblHeightSpacing); } if (isVTEBackgroundDrawEnabled()) { Label lblMargin = new Label(_("Margin")); - lblMargin.setHalign(GtkAlign.END); + lblMargin.setHalign(Align.End); grid.attach(lblMargin, 0, row, 1, 1); - SpinButton sbMargin = new SpinButton(0.0, 256.0, 4); - bh.bind(SETTINGS_PROFILE_MARGIN_KEY, sbMargin, "value", GSettingsBindFlags.DEFAULT); + SpinButton sbMargin = SpinButton.newWithRange(0.0, 256.0, 4); + bh.bind(SETTINGS_PROFILE_MARGIN_KEY, sbMargin, "value", SettingsBindFlags.Default); grid.attach(sbMargin, 1, row, 1, 1); row++; } @@ -356,10 +363,10 @@ protected: if (checkVTEVersion(VTE_VERSION_TEXT_BLINK_MODE)) { //Text Blink Mode Label lblTextBlinkMode = new Label(_("Text blink mode")); - lblTextBlinkMode.setHalign(GtkAlign.END); + lblTextBlinkMode.setHalign(Align.End); grid.attach(lblTextBlinkMode, 0, row, 1, 1); ComboBox cbTextBlinkMode = createNameValueCombo([_("Never"), _("Focused"), _("Unfocused"), _("Always")], SETTINGS_PROFILE_TEXT_BLINK_MODE_VALUES); - bh.bind(SETTINGS_PROFILE_TEXT_BLINK_MODE_KEY, cbTextBlinkMode, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_TEXT_BLINK_MODE_KEY, cbTextBlinkMode, "active-id", SettingsBindFlags.Default); grid.attach(cbTextBlinkMode, 1, row, 1, 1); row++; } @@ -367,85 +374,85 @@ protected: //Allow Bold // if (!checkVTEVersion(VTE_VERSION_BOLD_IS_BRIGHT)) { // CheckButton cbBold = new CheckButton(_("Allow bold text")); - // bh.bind(SETTINGS_PROFILE_ALLOW_BOLD_KEY, cbBold, "active", GSettingsBindFlags.DEFAULT); + // bh.bind(SETTINGS_PROFILE_ALLOW_BOLD_KEY, cbBold, "active", GSettingsBindFlags.Default); // grid.attach(cbBold, 1, row, 1, 1); // } //Rewrap on resize // CheckButton cbRewrap = new CheckButton(_("Rewrap on resize")); - // bh.bind(SETTINGS_PROFILE_REWRAP_KEY, cbRewrap, "active", GSettingsBindFlags.DEFAULT); + // bh.bind(SETTINGS_PROFILE_REWRAP_KEY, cbRewrap, "active", GSettingsBindFlags.Default); // b.add(cbRewrap); //Custom Font Label lblCustomFont = new Label(_("Custom font")); - lblCustomFont.setHalign(GtkAlign.END); + lblCustomFont.setHalign(Align.End); grid.attach(lblCustomFont, 0, row, 1, 1); - Box bFont = new Box(Orientation.HORIZONTAL, 12); + Box bFont = new Box(Orientation.Horizontal, 12); CheckButton cbCustomFont = new CheckButton(); - bh.bind(SETTINGS_PROFILE_USE_SYSTEM_FONT_KEY, cbCustomFont, "active", GSettingsBindFlags.DEFAULT | GSettingsBindFlags.INVERT_BOOLEAN); + bh.bind(SETTINGS_PROFILE_USE_SYSTEM_FONT_KEY, cbCustomFont, "active", SettingsBindFlags.Default | SettingsBindFlags.InvertBoolean); bFont.add(cbCustomFont); //Font Selector FontButton fbFont = new FontButton(); fbFont.setTitle(_("Choose A Terminal Font")); - bh.bind(SETTINGS_PROFILE_FONT_KEY, fbFont, "font-name", GSettingsBindFlags.DEFAULT); - bh.bind(SETTINGS_PROFILE_USE_SYSTEM_FONT_KEY, fbFont, "sensitive", GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY | GSettingsBindFlags - .INVERT_BOOLEAN); + bh.bind(SETTINGS_PROFILE_FONT_KEY, fbFont, "font-name", SettingsBindFlags.Default); + bh.bind(SETTINGS_PROFILE_USE_SYSTEM_FONT_KEY, fbFont, "sensitive", SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity | SettingsBindFlags + .InvertBoolean); bFont.add(fbFont); grid.attach(bFont, 1, row, 1, 1); row++; //Select-by-word-chars Label lblSelectByWordChars = new Label(_("Word-wise select chars")); - lblSelectByWordChars.setHalign(GtkAlign.END); + lblSelectByWordChars.setHalign(Align.End); grid.attach(lblSelectByWordChars, 0, row, 1, 1); Entry eSelectByWordChars = new Entry(); - bh.bind(SETTINGS_PROFILE_WORD_WISE_SELECT_CHARS_KEY, eSelectByWordChars, "text", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_WORD_WISE_SELECT_CHARS_KEY, eSelectByWordChars, "text", SettingsBindFlags.Default); grid.attach(eSelectByWordChars, 1, row, 1, 1); row++; Label lblCursorTitle = new Label(format("%s", _("Cursor"))); lblCursorTitle.setUseMarkup(true); - lblCursorTitle.setHalign(GtkAlign.START); + lblCursorTitle.setHalign(Align.Start); lblCursorTitle.setMarginTop(6); grid.attach(lblCursorTitle, 0, row, 2, 1); row++; //Cursor Shape Label lblCursorShape = new Label(_("Cursor")); - lblCursorShape.setHalign(GtkAlign.END); + lblCursorShape.setHalign(Align.End); grid.attach(lblCursorShape, 0, row, 1, 1); ComboBox cbCursorShape = createNameValueCombo([_("Block"), _("IBeam"), _("Underline")], [SETTINGS_PROFILE_CURSOR_SHAPE_BLOCK_VALUE, SETTINGS_PROFILE_CURSOR_SHAPE_IBEAM_VALUE, SETTINGS_PROFILE_CURSOR_SHAPE_UNDERLINE_VALUE]); - bh.bind(SETTINGS_PROFILE_CURSOR_SHAPE_KEY, cbCursorShape, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_CURSOR_SHAPE_KEY, cbCursorShape, "active-id", SettingsBindFlags.Default); grid.attach(cbCursorShape, 1, row, 1, 1); row++; //Cursor Blink Mode Label lblCursorBlinkMode = new Label(_("Cursor blink mode")); - lblCursorBlinkMode.setHalign(GtkAlign.END); + lblCursorBlinkMode.setHalign(Align.End); grid.attach(lblCursorBlinkMode, 0, row, 1, 1); ComboBox cbCursorBlinkMode = createNameValueCombo([_("System"), _("On"), _("Off")], SETTINGS_PROFILE_CURSOR_BLINK_MODE_VALUES); - bh.bind(SETTINGS_PROFILE_CURSOR_BLINK_MODE_KEY, cbCursorBlinkMode, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_CURSOR_BLINK_MODE_KEY, cbCursorBlinkMode, "active-id", SettingsBindFlags.Default); grid.attach(cbCursorBlinkMode, 1, row, 1, 1); row++; Label lblNotifyTitle = new Label(format("%s", _("Notification"))); lblNotifyTitle.setMarginTop(6); lblNotifyTitle.setUseMarkup(true); - lblNotifyTitle.setHalign(GtkAlign.START); + lblNotifyTitle.setHalign(Align.Start); grid.attach(lblNotifyTitle, 0, row, 2, 1); row++; //Terminal Bell Label lblBell = new Label(_("Terminal bell")); - lblBell.setHalign(GtkAlign.END); + lblBell.setHalign(Align.End); grid.attach(lblBell, 0, row, 1, 1); ComboBox cbBell = createNameValueCombo([_("None"), _("Sound"), _("Icon"), _("Icon and sound")], SETTINGS_PROFILE_TERMINAL_BELL_VALUES); - bh.bind(SETTINGS_PROFILE_TERMINAL_BELL_KEY, cbBell, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_TERMINAL_BELL_KEY, cbBell, "active-id", SettingsBindFlags.Default); grid.attach(cbBell, 1, row, 1, 1); row++; @@ -512,18 +519,18 @@ private: int row = 0; Label lblScheme = new Label(format("%s", _("Color scheme"))); lblScheme.setUseMarkup(true); - lblScheme.setHalign(GtkAlign.END); + lblScheme.setHalign(Align.End); grid.attach(lblScheme, 0, row, 1, 1); - cbScheme = new ComboBoxText(false); + cbScheme = new ComboBoxText(); cbScheme.setFocusOnClick(false); foreach (scheme; schemes) { cbScheme.append(scheme.id, scheme.name); } cbScheme.append("custom", _("Custom")); - cbScheme.setHalign(GtkAlign.FILL); + cbScheme.setHalign(Align.Fill); cbScheme.setHexpand(true); - schemeOnChangedHandle = cbScheme.addOnChanged(delegate(ComboBoxText cb) { + schemeOnChangedHandle = cbScheme.connectChanged(delegate(ComboBoxText cb) { if (cb.getActive >= 0) { if (cb.getActive() < schemes.length) { ColorScheme scheme = schemes[cb.getActive]; @@ -533,11 +540,11 @@ private: btnExport.setSensitive(cb.getActive() == schemes.length); }); - btnExport = new Button(_("Export")); - btnExport.addOnClicked(&exportColorScheme); + btnExport = Button.newWithLabel(_("Export")); + btnExport.connectClicked(&exportColorScheme); - Box bScheme = new Box(Orientation.HORIZONTAL, 6); - bScheme.setHalign(GtkAlign.FILL); + Box bScheme = new Box(Orientation.Horizontal, 6); + bScheme.setHalign(Align.Fill); bScheme.setHexpand(true); bScheme.add(cbScheme); bScheme.add(btnExport); @@ -547,16 +554,16 @@ private: Label lblPalette = new Label(format("%s", _("Color palette"))); lblPalette.setUseMarkup(true); - lblPalette.setHalign(GtkAlign.END); - lblPalette.setValign(GtkAlign.START); + lblPalette.setHalign(Align.End); + lblPalette.setValign(Align.Start); grid.attach(lblPalette, 0, row, 1, 1); grid.attach(createColorGrid(row), 1, row, 1, 1); row++; Label lblOptions = new Label(format("%s", _("Options"))); lblOptions.setUseMarkup(true); - lblOptions.setValign(GtkAlign.START); - lblOptions.setHalign(GtkAlign.END); + lblOptions.setValign(Align.Start); + lblOptions.setHalign(Align.End); grid.attach(lblOptions, 0, row, 1, 1); grid.attach(createOptions(), 1, row, 1, 1); row++; @@ -565,20 +572,20 @@ private: } Widget createOptions() { - Box box = new Box(Orientation.VERTICAL, 6); + Box box = new Box(Orientation.Vertical, 6); - cbUseThemeColors = new CheckButton(_("Use theme colors for foreground/background")); - cbUseThemeColors.addOnToggled(delegate(ToggleButton) { setCustomScheme(); }); - bh.bind(SETTINGS_PROFILE_USE_THEME_COLORS_KEY, cbUseThemeColors, "active", GSettingsBindFlags.DEFAULT); + cbUseThemeColors = CheckButton.newWithLabel(_("Use theme colors for foreground/background")); + cbUseThemeColors.connectToggled(delegate() { setCustomScheme(); }); + bh.bind(SETTINGS_PROFILE_USE_THEME_COLORS_KEY, cbUseThemeColors, "active", SettingsBindFlags.Default); MenuButton mbAdvanced = new MenuButton(); - mbAdvanced.add(createBox(Orientation.HORIZONTAL, 6, [new Label(_("Advanced")), new Image("pan-down-symbolic", IconSize.MENU)])); + mbAdvanced.add(createBox(Orientation.Horizontal, 6, [new Label(_("Advanced")), Image.newFromIconName("pan-down-symbolic", IconSize.Menu)])); mbAdvanced.setPopover(createPopover(mbAdvanced)); - box.add(createBox(Orientation.HORIZONTAL, 6, [cbUseThemeColors, mbAdvanced])); + box.add(createBox(Orientation.Horizontal, 6, [cbUseThemeColors, mbAdvanced])); if (checkVTEVersion(VTE_VERSION_BOLD_IS_BRIGHT)) { - CheckButton cbBoldIsBright = new CheckButton(_("Show bold text in bright colors")); - bh.bind(SETTINGS_PROFILE_BOLD_IS_BRIGHT_KEY, cbBoldIsBright, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbBoldIsBright = CheckButton.newWithLabel(_("Show bold text in bright colors")); + bh.bind(SETTINGS_PROFILE_BOLD_IS_BRIGHT_KEY, cbBoldIsBright, "active", SettingsBindFlags.Default); box.add(cbBoldIsBright); } @@ -590,29 +597,29 @@ private: GSettings gsSettings = new GSettings(SETTINGS_ID); if (gsSettings.getBoolean(SETTINGS_ENABLE_TRANSPARENCY_KEY)) { Label lblTransparent = new Label(_("Transparency")); - lblTransparent.setHalign(GtkAlign.END); + lblTransparent.setHalign(Align.End); lblTransparent.setHexpand(false); gSliders.attach(lblTransparent, 0, row, 1, 1); - Scale sTransparent = new Scale(Orientation.HORIZONTAL, 0, 100, 10); + Scale sTransparent = Scale.newWithRange(Orientation.Horizontal, 0, 100, 10); sTransparent.setDrawValue(false); sTransparent.setHexpand(true); - sTransparent.setHalign(GtkAlign.FILL); - bh.bind(SETTINGS_PROFILE_BG_TRANSPARENCY_KEY, sTransparent.getAdjustment(), "value", GSettingsBindFlags.DEFAULT); + sTransparent.setHalign(Align.Fill); + bh.bind(SETTINGS_PROFILE_BG_TRANSPARENCY_KEY, sTransparent.getAdjustment(), "value", SettingsBindFlags.Default); gSliders.attach(sTransparent, 1, row, 1, 1); row++; } Label lblDim = new Label(_("Unfocused dim")); - lblDim.setHalign(GtkAlign.END); + lblDim.setHalign(Align.End); lblDim.setHexpand(false); gSliders.attach(lblDim, 0, row, 1, 1); - Scale sDim = new Scale(Orientation.HORIZONTAL, 0, 100, 10); + Scale sDim = Scale.newWithRange(Orientation.Horizontal, 0, 100, 10); sDim.setDrawValue(false); sDim.setHexpand(true); - sDim.setHalign(GtkAlign.FILL); - bh.bind(SETTINGS_PROFILE_DIM_TRANSPARENCY_KEY, sDim.getAdjustment(), "value", GSettingsBindFlags.DEFAULT); + sDim.setHalign(Align.Fill); + bh.bind(SETTINGS_PROFILE_DIM_TRANSPARENCY_KEY, sDim.getAdjustment(), "value", SettingsBindFlags.Default); gSliders.attach(sDim, 1, row, 1, 1); box.add(gSliders); @@ -628,11 +635,11 @@ private: ColorButton createColorButton(string settingKey, string title, string sensitiveKey) { ColorButton result = new ColorButton(); if (sensitiveKey.length > 0) { - bh.bind(sensitiveKey, result, "sensitive", GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY); + bh.bind(sensitiveKey, result, "sensitive", SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity); } result.setTitle(title); - result.setHalign(GtkAlign.START); - result.addOnColorSet(delegate(ColorButton cb) { + result.setHalign(Align.Start); + result.connectColorSet(delegate(ColorButton cb) { if (!blockColorUpdates) { setCustomScheme(); RGBA color; @@ -656,9 +663,9 @@ private: row++; //Cursor - cbUseCursorColor = new CheckButton(_("Cursor")); - cbUseCursorColor.addOnToggled(delegate(ToggleButton) { setCustomScheme(); }); - bh.bind(SETTINGS_PROFILE_USE_CURSOR_COLOR_KEY, cbUseCursorColor, "active", GSettingsBindFlags.DEFAULT); + cbUseCursorColor = CheckButton.newWithLabel(_("Cursor")); + cbUseCursorColor.connectToggled(delegate() { setCustomScheme(); }); + bh.bind(SETTINGS_PROFILE_USE_CURSOR_COLOR_KEY, cbUseCursorColor, "active", SettingsBindFlags.Default); gColors.attach(cbUseCursorColor, 0, row, 1, 1); cbCursorFG = createColorButton(SETTINGS_PROFILE_CURSOR_FG_COLOR_KEY, _("Select Cursor Foreground Color"), SETTINGS_PROFILE_USE_CURSOR_COLOR_KEY); @@ -668,9 +675,9 @@ private: row++; //Highlight - cbUseHighlightColor = new CheckButton(_("Highlight")); - cbUseHighlightColor.addOnToggled(delegate(ToggleButton) { setCustomScheme(); }); - bh.bind(SETTINGS_PROFILE_USE_HIGHLIGHT_COLOR_KEY, cbUseHighlightColor, "active", GSettingsBindFlags.DEFAULT); + cbUseHighlightColor = CheckButton.newWithLabel(_("Highlight")); + cbUseHighlightColor.connectToggled(delegate() { setCustomScheme(); }); + bh.bind(SETTINGS_PROFILE_USE_HIGHLIGHT_COLOR_KEY, cbUseHighlightColor, "active", SettingsBindFlags.Default); gColors.attach(cbUseHighlightColor, 0, row, 1, 1); cbHighlightFG = createColorButton(SETTINGS_PROFILE_HIGHLIGHT_FG_COLOR_KEY, _("Select Highlight Foreground Color"), SETTINGS_PROFILE_USE_HIGHLIGHT_COLOR_KEY); @@ -680,9 +687,9 @@ private: row++; //Bold - cbUseBoldColor = new CheckButton(_("Bold")); - cbUseBoldColor.addOnToggled(delegate(ToggleButton) { setCustomScheme(); }); - bh.bind(SETTINGS_PROFILE_USE_BOLD_COLOR_KEY, cbUseBoldColor, "active", GSettingsBindFlags.DEFAULT); + cbUseBoldColor = CheckButton.newWithLabel(_("Bold")); + cbUseBoldColor.connectToggled(delegate() { setCustomScheme(); }); + bh.bind(SETTINGS_PROFILE_USE_BOLD_COLOR_KEY, cbUseBoldColor, "active", SettingsBindFlags.Default); gColors.attach(cbUseBoldColor, 0, row, 1, 1); cbBoldFG = createColorButton(SETTINGS_PROFILE_BOLD_COLOR_KEY, _("Select Bold Color"), SETTINGS_PROFILE_USE_BOLD_COLOR_KEY); @@ -690,9 +697,9 @@ private: row++; //Badge - cbUseBadgeColor = new CheckButton(_("Badge")); - cbUseBadgeColor.addOnToggled(delegate(ToggleButton) { setCustomScheme(); }); - bh.bind(SETTINGS_PROFILE_USE_BADGE_COLOR_KEY, cbUseBadgeColor, "active", GSettingsBindFlags.DEFAULT); + cbUseBadgeColor = CheckButton.newWithLabel(_("Badge")); + cbUseBadgeColor.connectToggled(delegate() { setCustomScheme(); }); + bh.bind(SETTINGS_PROFILE_USE_BADGE_COLOR_KEY, cbUseBadgeColor, "active", SettingsBindFlags.Default); cbBadgeFG = createColorButton(SETTINGS_PROFILE_BADGE_COLOR_KEY, _("Select Badge Color"), SETTINGS_PROFILE_USE_BADGE_COLOR_KEY); // Only attach badge components if badge feature is available @@ -741,10 +748,10 @@ private: gColors.setRowSpacing(6); cbBG = new ColorButton(); - bh.bind(SETTINGS_PROFILE_USE_THEME_COLORS_KEY, cbBG, "sensitive", GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY | GSettingsBindFlags - .INVERT_BOOLEAN); + bh.bind(SETTINGS_PROFILE_USE_THEME_COLORS_KEY, cbBG, "sensitive", SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity | SettingsBindFlags + .InvertBoolean); cbBG.setTitle(_("Select Background Color")); - cbBG.addOnColorSet(delegate(ColorButton cb) { + cbBG.connectColorSet(delegate(ColorButton cb) { if (!blockColorUpdates) { trace("Updating background color"); setCustomScheme(); @@ -757,10 +764,10 @@ private: gColors.attach(new Label(_("Background")), 1, row, 2, 1); cbFG = new ColorButton(); - bh.bind(SETTINGS_PROFILE_USE_THEME_COLORS_KEY, cbFG, "sensitive", GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY | GSettingsBindFlags - .INVERT_BOOLEAN); + bh.bind(SETTINGS_PROFILE_USE_THEME_COLORS_KEY, cbFG, "sensitive", SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity | SettingsBindFlags + .InvertBoolean); cbFG.setTitle(_("Select Foreground Color")); - cbFG.addOnColorSet(delegate(ColorButton cb) { + cbFG.connectColorSet(delegate(ColorButton cb) { if (!blockColorUpdates) { setCustomScheme(); RGBA color; @@ -782,14 +789,14 @@ private: int col = 0; for (int i = 0; i < colors.length; i++) { ColorButton cbNormal = new ColorButton(); - cbNormal.addOnColorSet(&onPaletteColorSet); + cbNormal.connectColorSet(&onPaletteColorSet); cbNormal.setData(PALETTE_COLOR_INDEX_KEY, cast(void*) i); cbNormal.setTitle(format(_("Select %s Color"), colors[i])); gColors.attach(cbNormal, col, row, 1, 1); cbPalette[i] = cbNormal; ColorButton cbLight = new ColorButton(); - cbLight.addOnColorSet(&onPaletteColorSet); + cbLight.connectColorSet(&onPaletteColorSet); cbLight.setData(PALETTE_COLOR_INDEX_KEY, cast(void*) i + 8); cbLight.setTitle(format(_("Select %s Light Color"), colors[i])); gColors.attach(cbLight, col + 1, row, 1, 1); @@ -867,15 +874,15 @@ private: trace(scheme); int index = findSchemeByColors(schemes, scheme); - import gobject.Signals; - Signals.handlerBlock(cbScheme, schemeOnChangedHandle); + import gobject.global : signalHandlerBlock, signalHandlerUnblock; + signalHandlerBlock(cbScheme, schemeOnChangedHandle); try { if (index < 0) cbScheme.setActive(to!int(schemes.length)); else cbScheme.setActive(index); } finally { - Signals.handlerUnblock(cbScheme, schemeOnChangedHandle); + signalHandlerUnblock(cbScheme, schemeOnChangedHandle); } } @@ -928,7 +935,7 @@ private: cbPalette[i].setRgba(color); palette[i] = rgbaTo8bitHex(color, false, true); } - gsProfile.setStrv(SETTINGS_PROFILE_PALETTE_COLOR_KEY, palette); + gsProfile.setStrv(SETTINGS_PROFILE_PALETTE_COLOR_KEY, palette[]); } /** @@ -941,15 +948,24 @@ private: } void exportColorScheme(Button button) { - FileChooserDialog fcd = new FileChooserDialog( - _("Export Color Scheme"), - cast(Window)this.getToplevel(), - FileChooserAction.SAVE, - [_("Save"), _("Cancel")]); + import gtk.c.functions : gtk_file_chooser_dialog_new; + import gtk.c.types : GtkFileChooserAction, GtkWidget, GtkWindow; + import std.typecons : No; + import std.string : toStringz; + + GtkWidget* widget = gtk_file_chooser_dialog_new( + toStringz(_("Export Color Scheme")), + cast(GtkWindow*) this.getToplevel()._cPtr(), + GtkFileChooserAction.Save, + toStringz(_("_Cancel")), ResponseType.Cancel, + toStringz(_("_Save")), ResponseType.Ok, + null + ); + FileChooserDialog fcd = new FileChooserDialog(cast(void*) widget, No.Take); scope (exit) fcd.destroy(); - string path = buildPath(Util.getUserConfigDir(), APPLICATION_CONFIG_FOLDER, SCHEMES_FOLDER); + string path = buildPath(getUserConfigDir(), APPLICATION_CONFIG_FOLDER, SCHEMES_FOLDER); if (!exists(path)) { mkdirRecurse(path); } @@ -966,10 +982,10 @@ private: fcd.addFilter(ff); fcd.setDoOverwriteConfirmation(true); - fcd.setDefaultResponse(ResponseType.OK); + fcd.setDefaultResponse(ResponseType.Ok); fcd.setCurrentName("Custom.json"); - if (fcd.run() == ResponseType.OK) { + if (fcd.run() == ResponseType.Ok) { string filename = fcd.getFilename(); ColorScheme scheme = getColorSchemeFromUI(); scheme.save(filename); @@ -986,8 +1002,8 @@ private: cbScheme.append(scheme.id, scheme.name); } cbScheme.append("custom", _("Custom")); - import gtk.Main; - Main.iterationDo(false); + import gtk.global : mainIterationDo; + mainIterationDo(false); initColorSchemeCombo(); } @@ -1019,26 +1035,26 @@ class ScrollPage : ProfilePage { private: void createUI() { - CheckButton cbShowScrollbar = new CheckButton(_("Show scrollbar")); - bh.bind(SETTINGS_PROFILE_SHOW_SCROLLBAR_KEY, cbShowScrollbar, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbShowScrollbar = CheckButton.newWithLabel(_("Show scrollbar")); + bh.bind(SETTINGS_PROFILE_SHOW_SCROLLBAR_KEY, cbShowScrollbar, "active", SettingsBindFlags.Default); add(cbShowScrollbar); - CheckButton cbScrollOnOutput = new CheckButton(_("Scroll on output")); - bh.bind(SETTINGS_PROFILE_SCROLL_ON_OUTPUT_KEY, cbScrollOnOutput, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbScrollOnOutput = CheckButton.newWithLabel(_("Scroll on output")); + bh.bind(SETTINGS_PROFILE_SCROLL_ON_OUTPUT_KEY, cbScrollOnOutput, "active", SettingsBindFlags.Default); add(cbScrollOnOutput); - CheckButton cbScrollOnKeystroke = new CheckButton(_("Scroll on keystroke")); - bh.bind(SETTINGS_PROFILE_SCROLL_ON_INPUT_KEY, cbScrollOnKeystroke, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbScrollOnKeystroke = CheckButton.newWithLabel(_("Scroll on keystroke")); + bh.bind(SETTINGS_PROFILE_SCROLL_ON_INPUT_KEY, cbScrollOnKeystroke, "active", SettingsBindFlags.Default); add(cbScrollOnKeystroke); - CheckButton cbLimitScroll = new CheckButton(_("Limit scrollback to:")); - bh.bind(SETTINGS_PROFILE_UNLIMITED_SCROLL_KEY, cbLimitScroll, "active", GSettingsBindFlags.DEFAULT | GSettingsBindFlags.INVERT_BOOLEAN); - SpinButton sbScrollbackSize = new SpinButton(256.0, to!double(int.max), 256.0); - bh.bind(SETTINGS_PROFILE_SCROLLBACK_LINES_KEY, sbScrollbackSize, "value", GSettingsBindFlags.DEFAULT); + CheckButton cbLimitScroll = CheckButton.newWithLabel(_("Limit scrollback to:")); + bh.bind(SETTINGS_PROFILE_UNLIMITED_SCROLL_KEY, cbLimitScroll, "active", SettingsBindFlags.Default | SettingsBindFlags.InvertBoolean); + SpinButton sbScrollbackSize = SpinButton.newWithRange(256.0, to!double(int.max), 256.0); + bh.bind(SETTINGS_PROFILE_SCROLLBACK_LINES_KEY, sbScrollbackSize, "value", SettingsBindFlags.Default); bh.bind(SETTINGS_PROFILE_UNLIMITED_SCROLL_KEY, sbScrollbackSize, "sensitive", - GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY | GSettingsBindFlags.INVERT_BOOLEAN); + SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity | SettingsBindFlags.InvertBoolean); - Box b = new Box(Orientation.HORIZONTAL, 12); + Box b = new Box(Orientation.Horizontal, 12); b.add(cbLimitScroll); b.add(sbScrollbackSize); add(b); @@ -1067,25 +1083,25 @@ private: int row = 0; Label lblBackspace = new Label(_("Backspace key generates")); - lblBackspace.setHalign(GtkAlign.END); + lblBackspace.setHalign(Align.End); grid.attach(lblBackspace, 0, row, 1, 1); ComboBox cbBackspace = createNameValueCombo([_("Automatic"), _("Control-H"), _("ASCII DEL"), _("Escape sequence"), _("TTY")], SETTINGS_PROFILE_ERASE_BINDING_VALUES); - bh.bind(SETTINGS_PROFILE_BACKSPACE_BINDING_KEY, cbBackspace, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_BACKSPACE_BINDING_KEY, cbBackspace, "active-id", SettingsBindFlags.Default); grid.attach(cbBackspace, 1, row, 1, 1); row++; Label lblDelete = new Label(_("Delete key generates")); - lblDelete.setHalign(GtkAlign.END); + lblDelete.setHalign(Align.End); grid.attach(lblDelete, 0, row, 1, 1); ComboBox cbDelete = createNameValueCombo([_("Automatic"), _("Control-H"), _("ASCII DEL"), _("Escape sequence"), _("TTY")], SETTINGS_PROFILE_ERASE_BINDING_VALUES); - bh.bind(SETTINGS_PROFILE_DELETE_BINDING_KEY, cbDelete, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_DELETE_BINDING_KEY, cbDelete, "active-id", SettingsBindFlags.Default); grid.attach(cbDelete, 1, row, 1, 1); row++; Label lblEncoding = new Label(_("Encoding")); - lblEncoding.setHalign(GtkAlign.END); + lblEncoding.setHalign(Align.End); grid.attach(lblEncoding, 0, row, 1, 1); string[] key, value; key.length = encodings.length; @@ -1095,15 +1111,15 @@ private: value[i] = encoding[0] ~ " " ~ _(encoding[1]); } ComboBox cbEncoding = createNameValueCombo(value, key); - bh.bind(SETTINGS_PROFILE_ENCODING_KEY, cbEncoding, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_ENCODING_KEY, cbEncoding, "active-id", SettingsBindFlags.Default); grid.attach(cbEncoding, 1, row, 1, 1); row++; Label lblCJK = new Label(_("Ambiguous-width characters")); - lblCJK.setHalign(GtkAlign.END); + lblCJK.setHalign(Align.End); grid.attach(lblCJK, 0, row, 1, 1); ComboBox cbCJK = createNameValueCombo([_("Narrow"), _("Wide")], SETTINGS_PROFILE_CJK_WIDTH_VALUES); - bh.bind(SETTINGS_PROFILE_CJK_WIDTH_KEY, cbCJK, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_CJK_WIDTH_KEY, cbCJK, "active-id", SettingsBindFlags.Default); grid.attach(cbCJK, 1, row, 1, 1); row++; @@ -1123,31 +1139,31 @@ class CommandPage : ProfilePage { private: void createUI() { - CheckButton cbLoginShell = new CheckButton(_("Run command as a login shell")); - bh.bind(SETTINGS_PROFILE_LOGIN_SHELL_KEY, cbLoginShell, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbLoginShell = CheckButton.newWithLabel(_("Run command as a login shell")); + bh.bind(SETTINGS_PROFILE_LOGIN_SHELL_KEY, cbLoginShell, "active", SettingsBindFlags.Default); add(cbLoginShell); - CheckButton cbCustomCommand = new CheckButton(_("Run a custom command instead of my shell")); - bh.bind(SETTINGS_PROFILE_USE_CUSTOM_COMMAND_KEY, cbCustomCommand, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbCustomCommand = CheckButton.newWithLabel(_("Run a custom command instead of my shell")); + bh.bind(SETTINGS_PROFILE_USE_CUSTOM_COMMAND_KEY, cbCustomCommand, "active", SettingsBindFlags.Default); add(cbCustomCommand); - Box bCommand = new Box(Orientation.HORIZONTAL, 12); + Box bCommand = new Box(Orientation.Horizontal, 12); bCommand.setMarginLeft(12); Label lblCommand = new Label(_("Command")); - bh.bind(SETTINGS_PROFILE_USE_CUSTOM_COMMAND_KEY, lblCommand, "sensitive", GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY); + bh.bind(SETTINGS_PROFILE_USE_CUSTOM_COMMAND_KEY, lblCommand, "sensitive", SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity); bCommand.add(lblCommand); Entry eCommand = new Entry(); eCommand.setHexpand(true); - bh.bind(SETTINGS_PROFILE_CUSTOM_COMMAND_KEY, eCommand, "text", GSettingsBindFlags.DEFAULT); - bh.bind(SETTINGS_PROFILE_USE_CUSTOM_COMMAND_KEY, eCommand, "sensitive", GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY); + bh.bind(SETTINGS_PROFILE_CUSTOM_COMMAND_KEY, eCommand, "text", SettingsBindFlags.Default); + bh.bind(SETTINGS_PROFILE_USE_CUSTOM_COMMAND_KEY, eCommand, "sensitive", SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity); bCommand.add(eCommand); add(bCommand); - Box bWhenExits = new Box(Orientation.HORIZONTAL, 12); + Box bWhenExits = new Box(Orientation.Horizontal, 12); Label lblWhenExists = new Label(_("When command exits")); bWhenExits.add(lblWhenExists); ComboBox cbWhenExists = createNameValueCombo([_("Exit the terminal"), _("Restart the command"), _("Hold the terminal open")], SETTINGS_PROFILE_EXIT_ACTION_VALUES); - bh.bind(SETTINGS_PROFILE_EXIT_ACTION_KEY, cbWhenExists, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_EXIT_ACTION_KEY, cbWhenExists, "active-id", SettingsBindFlags.Default); bWhenExits.add(cbWhenExists); add(bWhenExits); @@ -1173,12 +1189,12 @@ class BadgePage: ProfilePage { //Badge text Label lblBadge = new Label(_("Badge")); - lblBadge.setHalign(GtkAlign.END); + lblBadge.setHalign(Align.End); grid.attach(lblBadge, 0, row, 1, 1); Entry eBadge = new Entry(); eBadge.setHexpand(true); - bh.bind(SETTINGS_PROFILE_BADGE_TEXT_KEY, eBadge, "text", GSettingsBindFlags.DEFAULT); - if (Version.checkVersion(3, 16, 0).length == 0) { + bh.bind(SETTINGS_PROFILE_BADGE_TEXT_KEY, eBadge, "text", SettingsBindFlags.Default); + if (checkVersion(3, 16, 0).length == 0) { grid.attach(createTitleEditHelper(eBadge, TitleEditScope.TERMINAL), 1, row, 1, 1); } else { grid.attach(eBadge, 1, row, 1, 1); @@ -1187,31 +1203,31 @@ class BadgePage: ProfilePage { //Badge Position Label lblBadgePosition = new Label(_("Badge position")); - lblBadgePosition.setHalign(GtkAlign.END); + lblBadgePosition.setHalign(Align.End); grid.attach(lblBadgePosition, 0, row, 1, 1); ComboBox cbBadgePosition = createNameValueCombo([_("Northwest"), _("Northeast"), _("Southwest"), _("Southeast")], SETTINGS_QUADRANT_VALUES); - bh.bind(SETTINGS_PROFILE_BADGE_POSITION_KEY, cbBadgePosition, "active-id", GSettingsBindFlags.DEFAULT); + bh.bind(SETTINGS_PROFILE_BADGE_POSITION_KEY, cbBadgePosition, "active-id", SettingsBindFlags.Default); grid.attach(cbBadgePosition, 1, row, 1, 1); row++; //Custom Font Label lblCustomFont = new Label(_("Custom font")); - lblCustomFont.setHalign(GtkAlign.END); + lblCustomFont.setHalign(Align.End); grid.attach(lblCustomFont, 0, row, 1, 1); - Box bFont = new Box(Orientation.HORIZONTAL, 12); - CheckButton cbCustomFont = new CheckButton(); - bh.bind(SETTINGS_PROFILE_BADGE_USE_SYSTEM_FONT_KEY, cbCustomFont, "active", GSettingsBindFlags.DEFAULT | GSettingsBindFlags.INVERT_BOOLEAN); - bFont.add(cbCustomFont); + Box bFont = new Box(Orientation.Horizontal, 12); + CheckButton cbCustomFontBadge = new CheckButton(); + bh.bind(SETTINGS_PROFILE_BADGE_USE_SYSTEM_FONT_KEY, cbCustomFontBadge, "active", SettingsBindFlags.Default | SettingsBindFlags.InvertBoolean); + bFont.add(cbCustomFontBadge); //Font Selector FontButton fbFont = new FontButton(); fbFont.setTitle(_("Choose A Badge Font")); - bh.bind(SETTINGS_PROFILE_BADGE_FONT_KEY, fbFont, "font-name", GSettingsBindFlags.DEFAULT); - bh.bind(SETTINGS_PROFILE_BADGE_USE_SYSTEM_FONT_KEY, fbFont, "sensitive", GSettingsBindFlags.GET | GSettingsBindFlags.NO_SENSITIVITY | GSettingsBindFlags - .INVERT_BOOLEAN); + bh.bind(SETTINGS_PROFILE_BADGE_FONT_KEY, fbFont, "font-name", SettingsBindFlags.Default); + bh.bind(SETTINGS_PROFILE_BADGE_USE_SYSTEM_FONT_KEY, fbFont, "sensitive", SettingsBindFlags.Get | SettingsBindFlags.NoSensitivity | SettingsBindFlags + .InvertBoolean); bFont.add(fbFont); grid.attach(bFont, 1, row, 1, 1); row++; @@ -1248,7 +1264,7 @@ private: //Notify silence threshold Label lblSilenceTitle = new Label(format("%s", _("Notify New Activity"))); lblSilenceTitle.setUseMarkup(true); - lblSilenceTitle.setHalign(GtkAlign.START); + lblSilenceTitle.setHalign(Align.Start); lblSilenceTitle.setMarginTop(12); grid.attach(lblSilenceTitle, 0, row, 3, 1); row++; @@ -1268,7 +1284,7 @@ private: // Profile Switching Label lblProfileSwitching = new Label(format("%s", _("Automatic Profile Switching"))); lblProfileSwitching.setUseMarkup(true); - lblProfileSwitching.setHalign(GtkAlign.START); + lblProfileSwitching.setHalign(Align.Start); lblProfileSwitching.setMarginTop(12); grid.attach(lblProfileSwitching, 0, row, 3, 1); row++; @@ -1282,26 +1298,31 @@ private: grid.attach(createDescriptionLabel(profileSwitchingDescription),0,row,2,1); row++; - lsValues = new ListStore([GType.STRING]); - tvValues = new TreeView(lsValues); + lsValues = ListStore.new_([GTypes.STRING]); + tvValues = TreeView.newWithModel(lsValues); tvValues.setActivateOnSingleClick(true); - tvValues.addOnCursorChanged(delegate(TreeView) { + tvValues.connectCursorChanged(delegate() { updateUI(); }); - TreeViewColumn column = new TreeViewColumn(_("Match"), new CellRendererText(), "text", 0); + TreeViewColumn column = new TreeViewColumn(); + column.setTitle(_("Match")); + CellRendererText crtMatch = new CellRendererText(); + column.packStart(crtMatch, true); + column.addAttribute(crtMatch, "text", 0); tvValues.appendColumn(column); - ScrolledWindow scValues = new ScrolledWindow(tvValues); - scValues.setShadowType(ShadowType.ETCHED_IN); - scValues.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + ScrolledWindow scValues = new ScrolledWindow(); + scValues.add(tvValues); + scValues.setShadowType(ShadowType.EtchedIn); + scValues.setPolicy(PolicyType.Never, PolicyType.Automatic); scValues.setHexpand(true); - Box bButtons = new Box(Orientation.VERTICAL, 4); + Box bButtons = new Box(Orientation.Vertical, 4); bButtons.setVexpand(true); - btnAdd = new Button(_("Add")); - btnAdd.addOnClicked(delegate(Button) { + btnAdd = Button.newWithLabel(_("Add")); + btnAdd.connectClicked(delegate() { string label, value; if (checkVTEFeature(TerminalFeature.EVENT_SCREEN_CHANGED)) { label = _("Enter username@hostname:directory to match"); @@ -1309,8 +1330,9 @@ private: label = _("Enter hostname:directory to match"); } if (showInputDialog(cast(Window)getToplevel(), value, "", _("Add New Match"), label, &validateInput)) { - TreeIter iter = lsValues.createIter(); - lsValues.setValue(iter, 0, value); + TreeIter iter; + lsValues.append(iter); + lsValues.setValue(iter, 0, new Value(value)); storeValues(); selectRow(tvValues, lsValues.iterNChildren(null) - 1, null); } @@ -1318,8 +1340,8 @@ private: bButtons.add(btnAdd); - btnEdit = new Button(_("Edit")); - btnEdit.addOnClicked(delegate(Button) { + btnEdit = Button.newWithLabel(_("Edit")); + btnEdit.connectClicked(delegate() { TreeIter iter = tvValues.getSelectedIter(); if (iter !is null) { string value = lsValues.getValueString(iter, 0); @@ -1330,15 +1352,15 @@ private: label = _("Edit hostname:directory to match"); } if (showInputDialog(cast(Window)getToplevel(), value, value, _("Edit Match"), label, &validateInput)) { - lsValues.setValue(iter, 0, value); + lsValues.setValue(iter, 0, new Value(value)); storeValues(); } } }); bButtons.add(btnEdit); - btnDelete = new Button(_("Delete")); - btnDelete.addOnClicked(delegate(Button) { + btnDelete = Button.newWithLabel(_("Delete")); + btnDelete.connectClicked(delegate() { TreeIter iter = tvValues.getSelectedIter(); if (iter !is null) { lsValues.remove(iter); @@ -1361,21 +1383,21 @@ private: uint row = 0; Label lblSilence = new Label(_("Enable by default")); - lblSilence.setHalign(GtkAlign.END); + lblSilence.setHalign(Align.End); grid.attach(lblSilence, 0, row, 1, 1); - CheckButton cbSilence = new CheckButton(); - bh.bind(SETTINGS_PROFILE_NOTIFY_ENABLED_KEY, cbSilence, "active", GSettingsBindFlags.DEFAULT); - grid.attach(cbSilence, 1, row, 1, 1); + CheckButton cbSilenceNotify = new CheckButton(); + bh.bind(SETTINGS_PROFILE_NOTIFY_ENABLED_KEY, cbSilenceNotify, "active", SettingsBindFlags.Default); + grid.attach(cbSilenceNotify, 1, row, 1, 1); row++; Label lblSilenceDesc = new Label(_("Threshold for continuous silence")); - lblSilenceDesc.setHalign(GtkAlign.END); + lblSilenceDesc.setHalign(Align.End); grid.attach(lblSilenceDesc, 0, row, 1, 1); - Box bSilence = new Box(Orientation.HORIZONTAL, 4); - SpinButton sbSilence = new SpinButton(0, 3600, 60); - bh.bind(SETTINGS_PROFILE_NOTIFY_SILENCE_THRESHOLD_KEY, sbSilence, "value", GSettingsBindFlags.DEFAULT); + Box bSilence = new Box(Orientation.Horizontal, 4); + SpinButton sbSilence = SpinButton.newWithRange(0, 3600, 60); + bh.bind(SETTINGS_PROFILE_NOTIFY_SILENCE_THRESHOLD_KEY, sbSilence, "value", SettingsBindFlags.Default); bSilence.add(sbSilence); Label lblSilenceTime = new Label(_("(seconds)")); @@ -1399,8 +1421,9 @@ private: lsValues.clear(); string[] values = gsProfile.getStrv(SETTINGS_PROFILE_AUTOMATIC_SWITCH_KEY); foreach(value; values) { - TreeIter iter = lsValues.createIter(); - lsValues.setValue(iter, 0, value); + TreeIter iter; + lsValues.append(iter); + lsValues.setValue(iter, 0, new Value(value)); } } diff --git a/source/gx/tilix/prefeditor/titleeditor.d b/source/gx/tilix/prefeditor/titleeditor.d index ff0a6420f..9749a33f5 100644 --- a/source/gx/tilix/prefeditor/titleeditor.d +++ b/source/gx/tilix/prefeditor/titleeditor.d @@ -9,21 +9,24 @@ import std.experimental.logger; import std.format; import std.signals; -import gio.SimpleAction; -import gio.SimpleActionGroup; -import gio.Menu: GMenu = Menu; -import gio.MenuItem : GMenuItem = MenuItem; - -import glib.Variant: GVariant = Variant; -import glib.VariantType: GVariantType = VariantType; - -import gtk.Box; -import gtk.Entry; -import gtk.Image; -import gtk.Main; -import gtk.MenuButton; -import gtk.MountOperation; -import gtk.PopoverMenu; +import gio.simple_action : SimpleAction; +import gio.simple_action_group : SimpleActionGroup; +import gio.menu : GMenu = Menu; +import gio.menu_item : GMenuItem = MenuItem; + +import glib.variant : GVariant = Variant; +import glib.variant_type : GVariantType = VariantType; + +import std.typecons : Yes, No; + +import gtk.box : Box; +import gtk.entry : Entry; +import gtk.image : Image; +import gtk.global : getCurrentEventTime, showUri; +import gtk.menu_button : MenuButton; +import gtk.popover_menu : PopoverMenu; +import gtk.widget : Widget; +import gtk.types : IconSize, Orientation, ReliefStyle; import gx.gtk.actions; @@ -67,7 +70,7 @@ private: add(entry); MenuButton mbVariables = new MenuButton(); - mbVariables.add(new Image("pan-down-symbolic", IconSize.MENU)); + mbVariables.add(Image.newFromIconName("pan-down-symbolic", IconSize.Menu)); mbVariables.setFocusOnClick(false); mbVariables.setPopover(createPopover(tes)); add(mbVariables); @@ -81,7 +84,7 @@ private: foreach(index, variable; localized) { string actionName = format("%s-%02d", actionPrefix, index); SimpleAction action = new SimpleAction(actionName, null); - action.addOnActivate(delegate(GVariant, SimpleAction sa) { + action.connectActivate(delegate(GVariant param, SimpleAction sa) { string name = sa.getName(); int i = to!int("" ~ name[$-2 .. $]); int position = entry.getPosition(); @@ -119,21 +122,21 @@ private: // Help Menu Item GMenu helpSection = new GMenu(); SimpleAction saHelp = new SimpleAction("help", null); - saHelp.addOnActivate(delegate(GVariant, SimpleAction) { - MountOperation.showUri(null, "https://gnunn1.github.io/tilix-web/manual/title/", Main.getCurrentEventTime()); + saHelp.connectActivate(delegate(GVariant param, SimpleAction sa) { + showUri(null, "https://gnunn1.github.io/tilix-web/manual/title/", getCurrentEventTime()); }); sagVariables.insert(saHelp); helpSection.append(_("Help"), getActionDetailedName(ACTION_PREFIX, "help")); model.appendSection(_("Help"), helpSection); PopoverMenu pm = new PopoverMenu(); - pm.addOnMap(delegate(Widget) { + pm.connectMap(delegate() { onPopoverShow.emit(); }); - pm.addOnClosed(delegate(Widget) { + pm.connectClosed(delegate() { entry.grabFocus(); onPopoverClosed.emit(); - }, ConnectFlags.AFTER); + }, Yes.After); pm.bindModel(model, null); return pm; @@ -142,12 +145,12 @@ private: public: this(Entry entry, TitleEditScope tes) { - super(Orientation.HORIZONTAL, 0); + super(Orientation.Horizontal, 0); this.entry = entry; getStyleContext().addClass("linked"); setHexpand(true); createUI(tes); - addOnDestroy(delegate(Widget) { + connectDestroy(delegate() { sagVariables.destroy(); sagVariables = null; }); diff --git a/source/gx/tilix/preferences.d b/source/gx/tilix/preferences.d index f5c44e8d9..b657032a0 100644 --- a/source/gx/tilix/preferences.d +++ b/source/gx/tilix/preferences.d @@ -11,12 +11,13 @@ import std.range; import std.string; import std.uuid; -import gio.Settings : GSettings = Settings; +import gio.settings : GSettings = Settings; -import glib.Variant : GVariant = Variant; +import glib.variant : GVariant = Variant; import gx.i18n.l10n; import gx.util.array; +import gx.gtk.util : getSettingsStrv; import gx.tilix.common; import gx.tilix.constants; @@ -332,7 +333,7 @@ private: gsProfile.setString(SETTINGS_PROFILE_VISIBLE_NAME_KEY, profileName); trace("Set profile name " ~ profileName); - string[] ps = gsProfileList.getStrv(SETTINGS_PROFILE_LIST_KEY); + string[] ps = getSettingsStrv(gsProfileList, SETTINGS_PROFILE_LIST_KEY); trace("Get list of profiles"); ps ~= uuid; @@ -392,7 +393,7 @@ public: * @param uuid the identifier of the profile to delete */ void deleteProfile(string uuid) { - string[] ps = gsProfileList.getStrv(SETTINGS_PROFILE_LIST_KEY); + string[] ps = getSettingsStrv(gsProfileList, SETTINGS_PROFILE_LIST_KEY); gx.util.array.remove(ps, uuid); gsProfileList.setStrv(SETTINGS_PROFILE_LIST_KEY, ps); if (uuid == getDefaultProfile() && ps.length > 0) { @@ -439,7 +440,7 @@ public: */ ProfileInfo[] getProfiles() { ProfileInfo[] results; - string[] ps = gsProfileList.getStrv(SETTINGS_PROFILE_LIST_KEY); + string[] ps = getSettingsStrv(gsProfileList, SETTINGS_PROFILE_LIST_KEY); foreach (string uuid; ps) { results ~= getProfile(uuid); } @@ -447,7 +448,7 @@ public: } string[] getProfileUUIDs() { - return gsProfileList.getStrv(SETTINGS_PROFILE_LIST_KEY); + return getSettingsStrv(gsProfileList, SETTINGS_PROFILE_LIST_KEY); } string getProfileUUIDFromName(string profileName) { @@ -459,6 +460,19 @@ public: return null; } + /** + * Returns the ProfileInfo for a profile with the given name. + * Returns a ProfileInfo with empty uuid if not found. + */ + ProfileInfo getProfileByName(string profileName) { + ProfileInfo[] profiles = getProfiles(); + foreach (profile; profiles) { + if (profile.name == profileName) + return profile; + } + return ProfileInfo.init; + } + /** * Finds the profile that matches the current hostname and directory */ @@ -466,7 +480,7 @@ public: string[] uuids = getProfileUUIDs(); foreach (uuid; uuids) { GSettings settings = getProfileSettings(uuid); - string[] matches = settings.getStrv(SETTINGS_PROFILE_AUTOMATIC_SWITCH_KEY); + string[] matches = getSettingsStrv(settings, SETTINGS_PROFILE_AUTOMATIC_SWITCH_KEY); foreach (match; matches) { //is there a tilde in the directory right after the first colon? auto isTilde = match.indexOf(":~"); @@ -507,14 +521,14 @@ public: /** * Returns the GSettings object that corresponds to a specific profile. This - * object should not be shared between multiple classes. Also note that GtkD - * does not allow you to remove event handlers thus care should be taken to only - * connect from objects which will have a similar lifecycle as the settings. + * object should not be shared between multiple classes. Also note that the + * binding does not allow you to remove event handlers thus care should be taken + * to only connect from objects which will have a similar lifecycle as the settings. * * @param uuid The identifier of the profile */ GSettings getProfileSettings(string uuid) { - return new GSettings(SETTINGS_PROFILE_ID, getProfilePath(uuid)); + return GSettings.newWithPath(SETTINGS_PROFILE_ID, getProfilePath(uuid)); } /** diff --git a/source/gx/tilix/session.d b/source/gx/tilix/session.d index 93a4a127b..3a4c36854 100644 --- a/source/gx/tilix/session.d +++ b/source/gx/tilix/session.d @@ -14,46 +14,48 @@ import std.json; import std.string; import std.uuid; -import cairo.Context; -import cairo.ImageSurface; - -import gdkpixbuf.Pixbuf; - -import gdk.Atom; -import gdk.Cairo; -import gdk.Event; - -import gio.Settings : GSettings = Settings; - -import glib.Util; - -import gobject.ObjectG; -import gobject.ParamSpec; -import gobject.Value; - -import gtk.Application; -import gtk.Box; -import gtk.Button; -import gtk.Container; -import gtk.Clipboard; -import gtk.ComboBox; -import gtk.Dialog; -import gtk.Entry; -import gtk.Grid; -import gtk.Label; -import gtk.Main; -import gtk.Menu; -import gtk.MenuItem; -import gtk.Paned; -import gtk.Stack; -import gtk.Version; -import gtk.Widget; -import gtk.Window; +import cairo.context : Context; +import cairo.global : imageSurfaceCreate, create; +import cairo.surface : Surface; +import cairo.types : Format, Content; +import cairo.c.types : cairo_operator_t; + +import gdkpixbuf.pixbuf : Pixbuf; + +import gdk.event : Event; +import gdk.event_button : EventButton; +import gdk.c.types : GdkRectangle; +import gdk.types : EventType; + +import gio.settings : GSettings = Settings; + +import glib.global : getSystemDataDirs, getUserConfigDir; + +import gobject.value : Value; + +import gtk.box : Box; +import gtk.combo_box : ComboBox; +import gtk.container : Container; +import gtk.dialog : Dialog; +import gtk.entry : Entry; +import gtk.global : checkVersion; +import gtk.grid : Grid; +import gtk.label : Label; +import gtk.paned : Paned; +import gtk.stack : Stack; +import gtk.types : Align, Allocation, DialogFlags, ResponseType, Orientation, Stock; +import gtk.widget : Widget; +import gtk.window : Window; + +// GID does not provide gdk.keysyms, define required constants locally +private enum MouseButton { + PRIMARY = 1, +} import gx.gtk.cairo; import gx.gtk.dialog; import gx.gtk.threads; -import gx.gtk.util; +import gx.gtk.util : createNameValueCombo, findChildren; import gx.i18n.l10n; import gx.util.array; @@ -71,7 +73,9 @@ enum SessionStateChange { TERMINAL_FOCUSED, TERMINAL_TITLE, TERMINAL_OUTPUT, - SESSION_TITLE + SESSION_TITLE, + NAME, + FIND }; /** @@ -153,17 +157,17 @@ private: } void createBaseUI() { - stackGroup = new Box(Orientation.VERTICAL, 0); + stackGroup = new Box(Orientation.Vertical, 0); stackGroup.getStyleContext().addClass("tilix-background"); addNamed(stackGroup, STACK_GROUP_NAME); - stackMaximized = new Box(Orientation.VERTICAL, 0); + stackMaximized = new Box(Orientation.Vertical, 0); stackMaximized.getStyleContext().addClass("tilix-background"); addNamed(stackMaximized, STACK_MAX_NAME); - groupChild = new Box(Orientation.VERTICAL, 0); + groupChild = new Box(Orientation.Vertical, 0); stackGroup.add(groupChild); // Need this to switch the stack in case we loaded a layout // with a maximized terminal since stack can't be switched until realized - addOnRealize(delegate(Widget) { + connectRealize(delegate() { if (maximizedInfo.isMaximized) { setVisibleChild(stackMaximized); } @@ -194,12 +198,12 @@ private: */ TerminalPaned createPaned(Orientation orientation) { TerminalPaned result = new TerminalPaned(orientation); - if (Version.checkVersion(3, 16, 0).length == 0) { + if (checkVersion(3, 16, 0).length == 0) { result.setWideHandle(gsSettings.getBoolean(SETTINGS_ENABLE_WIDE_HANDLE_KEY)); } - result.addOnButtonPress(delegate(Event event, Widget w) { - if (event.button.window == result.getHandleWindow().getWindowStruct() && event.getEventType() == EventType.DOUBLE_BUTTON_PRESS && event.button.button == MouseButton.PRIMARY) { - redistributePanes(cast(Paned) w); + result.connectButtonPressEvent(delegate(EventButton event) { + if (event.window == result.getHandleWindow() && event.type == EventType._2buttonPress && event.button == MouseButton.PRIMARY) { + redistributePanes(result); return true; } return false; @@ -254,7 +258,7 @@ private: root.styleGetProperty("handle-size", handleSize); tracef("Handle size is %d", handleSize.getInt()); - int size = root.getOrientation() == Orientation.HORIZONTAL ? root.getAllocatedWidth() : root.getAllocatedHeight(); + int size = root.getOrientation() == Orientation.Horizontal ? root.getAllocatedWidth() : root.getAllocatedHeight(); int baseSize = (size - (handleSize.getInt() * model.count)) / (model.count + 1); tracef("Redistributing %d terminals with pos %d out of total size %d", model.count + 1, baseSize, size); @@ -453,10 +457,10 @@ private: //If terminal is maximized we can short-circuit check since // we know terminal's parent already if (maximizedInfo.isMaximized) { - return equal(box1, maximizedInfo.parent) ? box2 : box1; + return box1 is maximizedInfo.parent ? box2 : box1; } - Widget widget1 = gx.gtk.util.getChildren!(Widget)(box1, false)[0]; + Widget widget1 = findChildren!(Widget)(box1, false)[0]; Terminal terminal1 = cast(Terminal) widget1; @@ -487,7 +491,7 @@ private: //Fixes segmentation fault where when added box we created another layer of Box which caused the cast //to Paned to fail //Get child widget, could be Terminal or Paned - Widget widget = gx.gtk.util.getChildren!(Widget)(otherBox, false)[0]; + Widget widget = findChildren!(Widget)(otherBox, false)[0]; //Remove widget from original Box parent otherBox.remove(widget); //Add widget to new parent @@ -509,8 +513,8 @@ private: int height = parent.getAllocatedHeight(); int width = parent.getAllocatedWidth(); - Box b1 = new Box(Orientation.VERTICAL, 0); - Box b2 = new Box(Orientation.VERTICAL, 0); + Box b1 = new Box(Orientation.Vertical, 0); + Box b2 = new Box(Orientation.Vertical, 0); Paned paned = createPaned(orientation); paned.pack1(b1, PANED_RESIZE_MODE, PANED_SHRINK_MODE); @@ -527,10 +531,10 @@ private: } final switch (orientation) { - case Orientation.HORIZONTAL: + case Orientation.Horizontal: paned.setPosition(width / 2); break; - case Orientation.VERTICAL: + case Orientation.Vertical: paned.setPosition(height / 2); break; @@ -578,7 +582,7 @@ private: //Add terminal to this one addTerminal(src); } - Orientation orientation = (dq == DragQuadrant.TOP || dq == DragQuadrant.BOTTOM) ? Orientation.VERTICAL : Orientation.HORIZONTAL; + Orientation orientation = (dq == DragQuadrant.TOP || dq == DragQuadrant.BOTTOM) ? Orientation.Vertical : Orientation.Horizontal; int child = (dq == DragQuadrant.TOP || dq == DragQuadrant.LEFT) ? 1 : 2; //Inserting terminal //trace(format("Inserting terminal orient=$d, child=$d", orientation, child)); @@ -588,7 +592,7 @@ private: void closeTerminal(Terminal terminal) { removeTerminal(terminal); terminal.finalizeTerminal(); - //Try to avoid destroying things explicitly due to GtkD issue + //Try to avoid destroying things explicitly due to GTK binding reference handling terminal.destroy(); } @@ -760,7 +764,7 @@ private: void applyPreference(string key) { switch (key) { case SETTINGS_ENABLE_WIDE_HANDLE_KEY: - if (Version.checkVersion(3, 16, 0).length == 0) { + if (checkVersion(3, 16, 0).length == 0) { updateWideHandle(gsSettings.getBoolean(SETTINGS_ENABLE_WIDE_HANDLE_KEY)); } break; @@ -851,8 +855,8 @@ private: * Added to check for maximized state and grab right terminal */ void serializeBox(string node, Box box) { - Widget[] widgets = gx.gtk.util.getChildren!(Widget)(box, false); - if (widgets.length == 0 && maximizedInfo.isMaximized && equal(box, maximizedInfo.parent)) { + Widget[] widgets = findChildren!(Widget)(box, false); + if (widgets.length == 0 && maximizedInfo.isMaximized && box is maximizedInfo.parent) { value.object[node] = serializeWidget(maximizedInfo.terminal, sizeInfo); } else { value.object[node] = serializeWidget(widgets[0], sizeInfo); @@ -881,7 +885,7 @@ private: value[NODE_WIDTH] = JSONValue(terminal.getAllocatedWidth()); value[NODE_HEIGHT] = JSONValue(terminal.getAllocatedHeight()); value[NODE_UUID] = terminal.uuid; - if (maximizedInfo.isMaximized && equal(terminal, maximizedInfo.terminal)) { + if (maximizedInfo.isMaximized && terminal is maximizedInfo.terminal) { value[NODE_MAXIMIZED] = JSONValue(true); } return terminal.serialize(value); @@ -925,9 +929,9 @@ private: trace("Loading paned"); Orientation orientation = cast(Orientation) value[NODE_ORIENTATION].integer(); TerminalPaned paned = createPaned(orientation); - Box b1 = new Box(Orientation.VERTICAL, 0); + Box b1 = new Box(Orientation.Vertical, 0); b1.add(parseNode(value[NODE_CHILD1], sizeInfo)); - Box b2 = new Box(Orientation.VERTICAL, 0); + Box b2 = new Box(Orientation.Vertical, 0); b2.add(parseNode(value[NODE_CHILD2], sizeInfo)); paned.pack1(b1, PANED_RESIZE_MODE, PANED_SHRINK_MODE); paned.pack2(b2, PANED_RESIZE_MODE, PANED_SHRINK_MODE); @@ -994,22 +998,22 @@ private: void initSession() { gsSettings = new GSettings(SETTINGS_ID); - gsSettings.addOnChanged(delegate(string key, GSettings) { + gsSettings.connectChanged(null, delegate(string key, GSettings gs) { applyPreference(key); }); getStyleContext.addClass("tilix-background"); - addOnDraw(&onDraw); + connectDraw(&onDraw); } - bool onDraw(Scoped!Context cr, Widget w) { + bool onDraw(Context cr, Widget w) { AppWindow window = cast(AppWindow)getToplevel(); if (window is null) return false; Container child = cast(Container) getVisibleChild(); if (child is null) return false; //Cached render - ImageSurface isBGImage = window.getBackgroundImage(child); + Surface isBGImage = window.getBackgroundImage(child); if (isBGImage is null) return false; cr.save(); @@ -1019,20 +1023,19 @@ private: cr.paint(); //Draw child onto temporary image so it doesn't overdraw background - import cairo.Surface: Surface; - Surface isChildSurface = cr.getTarget().createSimilar(cairo_content_t.COLOR_ALPHA, child.getAllocatedWidth(), child.getAllocatedHeight()); + Surface isChildSurface = cr.getTarget().createSimilar(Content.ColorAlpha, child.getAllocatedWidth(), child.getAllocatedHeight()); if (isChildSurface is null) { trace("****** ImageSurface is null"); - isChildSurface = ImageSurface.create(cairo_format_t.ARGB32, child.getAllocatedWidth(), child.getAllocatedHeight()); + isChildSurface = imageSurfaceCreate(Format.Argb32, child.getAllocatedWidth(), child.getAllocatedHeight()); } - Context crChild = Context.create(isChildSurface); + Context crChild = create(isChildSurface); scope (exit) { crChild.destroy(); isChildSurface.destroy(); } propagateDraw(child, crChild); cr.setSourceSurface(isChildSurface, 0, 0); - cr.setOperator(cairo_operator_t.OVER); + cr.setOperator(cairo_operator_t.Over); cr.paint(); cr.restore(); @@ -1040,8 +1043,8 @@ private: } void updateWideHandle(bool value) { - if (Version.checkVersion(3, 16, 0).length == 0) { - Paned[] all = gx.gtk.util.getChildren!(Paned)(stackGroup, true); + if (checkVersion(3, 16, 0).length == 0) { + Paned[] all = findChildren!(Paned)(stackGroup, true); tracef("Updating wide handle for %d paned", all.length); foreach (paned; all) { paned.setWideHandle(value); @@ -1058,13 +1061,19 @@ public: * name = The name of the session */ this(string name) { + this(name, null, null); + } + + this(string name, string profileUUID, string workingDir) { super(); initSession(); createBaseUI(); _sessionUUID = randomUUID().toString(); _name = name; - - this.addOnDestroy(delegate(Widget) { + if (profileUUID !is null || workingDir !is null) { + initSession(profileUUID, workingDir, false); + } + this.connectDestroy(delegate() { // Never use experimental logging in destructors, causes // memory exceptions on GC for some reason @@ -1163,7 +1172,7 @@ public: JSONValue serialize() { // Force all Paned to update their ratios, needed when upgrading from pre-ratio files - TerminalPaned[] panes = gx.gtk.util.getChildren!TerminalPaned(stackGroup, true); + TerminalPaned[] panes = findChildren!TerminalPaned(stackGroup, true); foreach(paned; panes) { trace("Updating paned position after session load"); paned.updateRatio(); @@ -1177,7 +1186,7 @@ public: root.object[NODE_WIDTH] = JSONValue(getAllocatedWidth()); root.object[NODE_HEIGHT] = JSONValue(getAllocatedHeight()); SessionSizeInfo sizeInfo = SessionSizeInfo(getAllocatedWidth(), getAllocatedHeight()); - root.object[NODE_CHILD] = serializeWidget(gx.gtk.util.getChildren!(Widget)(groupChild, false)[0], sizeInfo); + root.object[NODE_CHILD] = serializeWidget(findChildren!(Widget)(groupChild, false)[0], sizeInfo); root.object[NODE_UUID] = _sessionUUID; root[NODE_TYPE] = WidgetType.SESSION; setlocale(LC_ALL, null); @@ -1226,11 +1235,11 @@ public: /** * The name of the session */ - @property string name() { + @property override string name() { return _name; } - @property void name(string value) { + @property override void name(string value) { if (value.length > 0) { _name = value; onSessionTitleChange(); @@ -1292,6 +1301,11 @@ public: return false; } + bool isSearching() { + // Returns whether the session is in search mode + return false; // Placeholder - actual implementation would check search state + } + /** * Returns information about any running processes in the terminal. */ @@ -1324,12 +1338,12 @@ public: TerminalPaned paned = cast(TerminalPaned) parent; trace("Testing Paned"); if (paned !is null) { - if ((direction == "up" || direction == "down") && paned.getOrientation() == Orientation.VERTICAL) { + if ((direction == "up" || direction == "down") && paned.getOrientation() == Orientation.Vertical) { trace("Resizing " ~ direction); paned.setPosition(paned.getPosition() + increment); paned.updateRatio(); return; - } else if ((direction == "left" || direction == "right") && paned.getOrientation() == Orientation.HORIZONTAL) { + } else if ((direction == "left" || direction == "right") && paned.getOrientation() == Orientation.Horizontal) { trace("Resizing " ~ direction); paned.setPosition(paned.getPosition() + increment); paned.updateRatio(); @@ -1387,8 +1401,9 @@ public: trace("Focusing ", direction); Widget appWindow = currentTerminal.getToplevel(); - GtkAllocation appWindowAllocation; - appWindow.getClip(appWindowAllocation); + GdkRectangle appWindowAllocation; + appWindowAllocation.width = appWindow.getAllocatedWidth(); + appWindowAllocation.height = appWindow.getAllocatedHeight(); // Start at the top left of the current terminal int xPos, yPos; @@ -1424,8 +1439,9 @@ public: int termX, termY; terminal.translateCoordinates(appWindow, 0, 0, termX, termY); - GtkAllocation termAllocation; - terminal.getClip(termAllocation); + GdkRectangle termAllocation; + termAllocation.width = terminal.getAllocatedWidth(); + termAllocation.height = terminal.getAllocatedHeight(); if (xPos >= termX && yPos >= termY && xPos <= (termX + termAllocation.width) && yPos <= (termY + termAllocation.height)) { focusTerminal(terminal); @@ -1465,6 +1481,13 @@ public: return false; } + /** + * Activate a terminal by UUID (alias for focusTerminal) + */ + bool activateTerminal(string uuid) { + return focusTerminal(uuid); + } + void toggleTerminalFind() { if (currentTerminal !is null) { currentTerminal.toggleFind(); @@ -1494,9 +1517,9 @@ public: int width = currentTerminal.getAllocatedWidth(); if (height < width) { - addNewTerminal(currentTerminal, Orientation.HORIZONTAL); + addNewTerminal(currentTerminal, Orientation.Horizontal); } else { - addNewTerminal(currentTerminal, Orientation.VERTICAL); + addNewTerminal(currentTerminal, Orientation.Vertical); } } } @@ -1523,7 +1546,10 @@ public: * listens to this event and removes the session when received. */ GenericEvent!(Session) onClose; - + /** + * An event that occurs when the user requests to close the session. + */ + GenericEvent!(Session) onUserClose; /** * Occurs when a terminal is detached. * @@ -1571,7 +1597,7 @@ private: Label label = new Label(format("%s", _("Name"))); label.setUseMarkup(true); - label.setHalign(GtkAlign.END); + label.setHalign(Align.End); grid.attach(label, 0, 0, 1, 1); eName = new Entry(); @@ -1582,7 +1608,7 @@ private: label = new Label(format("%s", _("Profile"))); label.setUseMarkup(true); - label.setHalign(GtkAlign.END); + label.setHalign(Align.End); grid.attach(label, 0, 1, 1, 1); ProfileInfo[] profiles = prfMgr.getProfiles(); @@ -1603,12 +1629,17 @@ private: public: this(Window parent, string name, string profileUUID) { - super(_("New Session"), parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [StockID.CANCEL, StockID.OK], [ResponseType.CANCEL, ResponseType.OK]); - setDefaultResponse(ResponseType.OK); + super(); + setTitle(_("New Session")); + setTransientFor(parent); + setModal(true); + addButton(_("_Cancel"), ResponseType.Cancel); + addButton(_("_OK"), ResponseType.Ok); + setDefaultResponse(ResponseType.Ok); createUI(name, profileUUID); } - @property string name() { + @property override string name() { return eName.getText(); } @@ -1638,16 +1669,16 @@ private: public: this(Orientation orientation) { super(orientation); - addOnSizeAllocate(delegate(GdkRectangle* rect, Widget) { + connectSizeAllocate(delegate(Allocation rect) { updatePosition(); }); - addOnButtonRelease(delegate(Event event, Widget w) { + connectButtonReleaseEvent(delegate(EventButton event) { updateRatio(); return false; }); - addOnAcceptPosition(delegate(Paned) { + connectAcceptPosition(delegate() { updateRatio(); return false; }); @@ -1656,7 +1687,7 @@ public: void updateRatio() { //trace("Updating ratio"); double newRatio = ratio; - if (getOrientation() == Orientation.HORIZONTAL) { + if (getOrientation() == Orientation.Horizontal) { newRatio = to!double(getChild1().getAllocatedWidth()) / to!double(getAllocatedWidth()); //tracef("Child1 Width=%d, Paned Width=%d, newRatio=%f",getChild1().getAllocatedWidth(),getAllocatedWidth(), newRatio); } else { @@ -1672,7 +1703,7 @@ public: void updatePosition(bool force = false) { if (ignoreRatio) return; //tracef("TerminalPaned Size allocated, ratio %f", ratio); - if (getOrientation() == Orientation.HORIZONTAL) { + if (getOrientation() == Orientation.Horizontal) { if (force || lastWidth != getAllocatedWidth()) { int position = to!int(to!double(getAllocatedWidth()) * ratio); setPosition(position); @@ -1725,18 +1756,18 @@ struct SessionSizeInfo { double scalePosition(int position, Orientation orientation) { final switch (orientation) { - case Orientation.HORIZONTAL: + case Orientation.Horizontal: return to!double(position) / to!double(width); - case Orientation.VERTICAL: + case Orientation.Vertical: return to!double(position) / to!double(height); } } int getPosition(double scaledPosition, Orientation orientation) { final switch (orientation) { - case Orientation.HORIZONTAL: + case Orientation.Horizontal: return to!int(scaledPosition * width); - case Orientation.VERTICAL: + case Orientation.Vertical: return to!int(scaledPosition * height); } } @@ -1776,8 +1807,8 @@ private: PanedNode result = new PanedNode(node); Box box1 = cast(Box) node.getChild1(); Box box2 = cast(Box) node.getChild2(); - Paned[] paned1 = gx.gtk.util.getChildren!(Paned)(box1, false); - Paned[] paned2 = gx.gtk.util.getChildren!(Paned)(box2, false); + Paned[] paned1 = findChildren!(Paned)(box1, false); + Paned[] paned2 = findChildren!(Paned)(box2, false); if (paned1.length > 0 && paned1[0].getOrientation() == node.getOrientation()) result.child[0] = createModel(paned1[0]); if (paned2.length > 0 && paned2[0].getOrientation() == node.getOrientation()) diff --git a/source/gx/tilix/shortcuts.d b/source/gx/tilix/shortcuts.d index e56bec179..1d334d90e 100644 --- a/source/gx/tilix/shortcuts.d +++ b/source/gx/tilix/shortcuts.d @@ -7,18 +7,17 @@ module gx.tilix.shortcuts; import std.algorithm; import std.experimental.logger; import std.path; +import std.typecons : Yes; -import gio.Settings; +import gio.settings : Settings; -import gobject.ObjectG; -import gobject.Value; +import gobject.c.functions : g_object_new; +import gobject.c.types : GObject; -import gtkc.gobject; - -import gtk.Builder; -import gtk.ShortcutsGroup; -import gtk.ShortcutsShortcut; -import gtk.ShortcutsWindow; +import gtk.builder : Builder; +import gtk.shortcuts_group : ShortcutsGroup; +import gtk.shortcuts_shortcut : ShortcutsShortcut; +import gtk.shortcuts_window : ShortcutsWindow; import gx.gtk.actions; import gx.i18n.l10n; @@ -58,7 +57,11 @@ ShortcutsWindow getShortcutWindow() { string accelName = gsProfile.getString(SETTINGS_PROFILE_SHORTCUT_KEY); if (accelName == SHORTCUT_DISABLED) accelName.length = 0; trace("Create ShortcutShortcut"); - ShortcutsShortcut ss = cast(ShortcutsShortcut) new ObjectG(ShortcutsShortcut.getType(), ["title","accelerator"], [new Value(gsProfile.getString(SETTINGS_PROFILE_VISIBLE_NAME_KEY)), new Value(accelName)]); + // Create ShortcutsShortcut via C API and wrap with GID + GObject* cObj = g_object_new(ShortcutsShortcut._getGType(), null); + ShortcutsShortcut ss = new ShortcutsShortcut(cast(void*)cObj, Yes.Take); + ss.title = gsProfile.getString(SETTINGS_PROFILE_VISIBLE_NAME_KEY); + ss.accelerator = accelName; if (ss !is null) { sgProfile.add(ss); } else { diff --git a/source/gx/tilix/sidebar.d b/source/gx/tilix/sidebar.d index 2330f5ac0..6b36cfc72 100644 --- a/source/gx/tilix/sidebar.d +++ b/source/gx/tilix/sidebar.d @@ -9,38 +9,56 @@ import std.conv; import std.format; import std.experimental.logger; -import gdk.Atom; -import gdk.DragContext; -import gdk.Event; -import gdk.Keysyms; -import gdk.Pixbuf; -import gdk.Screen; -import gdk.Window: GdkWindow = Window; - -import gio.Settings : GSettings = Settings; - -import gobject.Signals; - -import gtk.Adjustment; -import gtk.AspectFrame; -import gtk.Box; -import gtk.Button; -import gtk.DragAndDrop; -import gtk.EventBox; -import gtk.Frame; -import gtk.Grid; -import gtk.Image; -import gtk.Label; -import gtk.ListBox; -import gtk.ListBoxRow; -import gtk.Main; -import gtk.Overlay; -import gtk.Revealer; -import gtk.ScrolledWindow; -import gtk.SelectionData; -import gtk.TargetEntry; -import gtk.Widget; -import gtk.Window; +import gdk.atom : Atom; +import gdk.drag_context : DragContext; +import gdk.event : Event; +import gdk.event_button : EventButton; +import gdk.event_key : EventKey; +import gdk.screen : Screen; +import gdk.window : GdkWindow = Window; + +import gdkpixbuf.pixbuf : Pixbuf; + +import gio.settings : GSettings = Settings; + +import glib.c.types : gulong; + +import gobject.global : signalHandlerDisconnect; + +import gtk.adjustment : Adjustment; +import gtk.aspect_frame : AspectFrame; +import gtk.box : Box; +import gtk.button : Button; +import gtk.global : dragSetIconWidget; +import gtk.event_box : EventBox; +import gtk.frame : Frame; +import gtk.grid : Grid; +import gtk.image : Image; +import gtk.label : Label; +import gtk.list_box : ListBox; +import gtk.list_box_row : ListBoxRow; +import gtk.overlay : Overlay; +import gtk.revealer : Revealer; +import gtk.scrolled_window : ScrolledWindow; +import gtk.selection_data : SelectionData; +import gtk.target_entry : TargetEntry; +import gtk.types : DestDefaults, Align, IconSize, Orientation, PolicyType, ReliefStyle, RevealerTransitionType, SelectionMode, ShadowType, TargetFlags; +import gtk.c.types : GtkDragResult, GtkWindowType; +import gdk.types : DragAction, ModifierType; +import gdk.c.types : GdkModifierType; +import gid.gid : No, Yes; +import pango.types : EllipsizeMode; +import gtk.widget : Widget; +import gtk.window : Window; + +// GID does not provide gdk.keysyms, so define the required key constants locally +private enum GdkKeysyms { + GDK_Escape = 0xff1b, + GDK_Page_Up = 0xff55, + GDK_Page_Down = 0xff56, + GDK_0 = 0x030, + GDK_9 = 0x039, +} import gx.gtk.cairo; import gx.gtk.util; @@ -85,17 +103,20 @@ private: onSessionDetach.emit(sessionUUID, x, y); } - bool onButtonPress(Event event, Widget w) { + bool onButtonPress(EventButton event) { trace("** Sidebar button press"); + if (event is null) return false; // If button press happened outside of sidebar close it // Modified since DND uses eventbox so additional windows in play - if (event.getWindow() !is null && lbSessions.getWindow() !is null) { - if (event.getWindow().getWindowStruct() == getWindow().getWindowStruct() || event.getWindow().getWindowStruct() == lbSessions.getWindow().getWindowStruct()) { + GdkWindow eventWindow = event.window; + GdkWindow lbWindow = lbSessions.getWindow(); + if (eventWindow !is null && lbWindow !is null) { + if (eventWindow is getWindow() || eventWindow is lbWindow) { return false; } - GdkWindow[] windows = lbSessions.getWindow().getChildren().toArray!GdkWindow(); - foreach(window; windows) { - if (event.getWindow().getWindowStruct() == window.getWindowStruct()) { + GdkWindow[] windows = lbWindow.getChildren(); + foreach(w; windows) { + if (eventWindow is w) { return false; } } @@ -105,6 +126,7 @@ private: return false; } +public: void removeSession(string sessionUUID) { trace("Removing session " ~ sessionUUID); SideBarRow row = getRow(sessionUUID); @@ -120,14 +142,33 @@ private: } } + void addSession(Session session) { + import gx.tilix.session : Session; + if (session is null) return; + // Create a new row for this session + SideBarRow row = new SideBarRow(this, session, null, 200, 150); + lbSessions.add(row); + reindexSessions(); + } + //Re-number the indexes, used after a delete void reindexSessions() { - SideBarRow[] rows = gx.gtk.util.getChildren!SideBarRow(lbSessions, false); + SideBarRow[] rows = gx.gtk.util.findChildren!SideBarRow(lbSessions, false); foreach(i, row; rows) { row.sessionIndex = i + 1; } } + /** + * Update the recent files list in the sidebar + * Called when recent session files list changes + */ + void updateRecentFiles(string[] recentFiles) { + // TODO: Implement recent files UI update in sidebar + // For now this is a stub to allow compilation + trace("updateRecentFiles called with " ~ to!string(recentFiles.length) ~ " files"); + } + void reorderSessions(string sourceUUID, string targetUUID, bool after = false) { if (sourceUUID == targetUUID) return; SideBarRow source = getRow(sourceUUID); @@ -155,7 +196,7 @@ private: if (!after) { lbSessions.insert(source, index); } else { - if (index == lbSessions.getChildren().length() -1) { + if (index == lbSessions.getChildren().length -1) { lbSessions.add(source); } else { lbSessions.insert(source, index + 1); @@ -165,12 +206,13 @@ private: lbSessions.selectRow(source); } - bool onKeyPress(Event event, Widget w) { - uint keyval; - if (event.getKeyval(keyval)) { - switch (keyval) { - case GdkKeysyms.GDK_Page_Up: - if (event.key.state & ModifierType.CONTROL_MASK) { + bool onKeyPress(EventKey event) { + if (event is null) return false; + uint keyval = event.keyval; + auto state = event.state; + switch (keyval) { + case GdkKeysyms.GDK_Page_Up: + if (state & ModifierType.ControlMask) { SideBarRow source = cast(SideBarRow)lbSessions.getSelectedRow(); if (source is null) { trace("No selected row"); @@ -181,11 +223,11 @@ private: SideBarRow target = cast(SideBarRow)lbSessions.getRowAtIndex(index - 1); reorderSessions(source, target); } - return true; - } - break; - case GdkKeysyms.GDK_Page_Down: - if (event.key.state & ModifierType.CONTROL_MASK) { + return true; + } + break; + case GdkKeysyms.GDK_Page_Down: + if (state & ModifierType.ControlMask) { trace("Moving row down"); SideBarRow source = cast(SideBarRow)lbSessions.getSelectedRow(); if (source is null) { @@ -197,41 +239,39 @@ private: SideBarRow target = cast(SideBarRow)lbSessions.getRowAtIndex(index + 1); reorderSessions(source, target, true); } - return true; - } - break; - default: - break; + return true; } + break; + default: + break; } return false; } - bool onKeyRelease(Event event, Widget w) { - uint keyval; - if (event.getKeyval(keyval)) { - switch (keyval) { - //If escape key is pressed, close sidebar - case GdkKeysyms.GDK_Escape: - notifySessionSelected(null); - break; - case GdkKeysyms.GDK_0: - .. - case GdkKeysyms.GDK_9: - int num = keyval - GdkKeysyms.GDK_0 - 1; - if (num == -1) num = 10; - ListBoxRow row = lbSessions.getRowAtIndex(num); - if (row !is null) { - lbSessions.selectRow(row); - SideBarRow sr = cast(SideBarRow) row; - if (sr !is null && !blockSelectedHandler) { - notifySessionSelected(sr.sessionUUID); - } + bool onKeyRelease(EventKey event) { + if (event is null) return false; + uint keyval = event.keyval; + switch (keyval) { + //If escape key is pressed, close sidebar + case GdkKeysyms.GDK_Escape: + notifySessionSelected(null); + break; + case GdkKeysyms.GDK_0: + .. + case GdkKeysyms.GDK_9: + int num = keyval - GdkKeysyms.GDK_0 - 1; + if (num == -1) num = 10; + ListBoxRow row = lbSessions.getRowAtIndex(num); + if (row !is null) { + lbSessions.selectRow(row); + SideBarRow sr = cast(SideBarRow) row; + if (sr !is null && !blockSelectedHandler) { + notifySessionSelected(sr.sessionUUID); } - break; - default: - //Ignore other keys } + break; + default: + //Ignore other keys } return false; } @@ -242,7 +282,7 @@ private: /* bool onKeyNavFailed(GtkDirectionType direction, Widget) { trace("OnKeyNavFailed called"); - SideBarRow[] rows = gx.gtk.util.getChildren!(SideBarRow)(lbSessions, false); + SideBarRow[] rows = gx.gtk.util.findChildren!(SideBarRow)(lbSessions, false); switch (direction) { case GtkDirectionType.DOWN: if (lbSessions.getSelectedRow() == rows[rows.length - 1]) { @@ -264,7 +304,7 @@ private: */ SideBarRow getRow(string sessionUUID) { - SideBarRow[] rows = gx.gtk.util.getChildren!SideBarRow(lbSessions, false); + SideBarRow[] rows = gx.gtk.util.findChildren!SideBarRow(lbSessions, false); foreach(row; rows) { if (row.sessionUUID == sessionUUID) { return row; @@ -275,11 +315,11 @@ private: void setSidebarPosition() { if (gsSettings.getBoolean(SETTINGS_SIDEBAR_RIGHT)) { - setTransitionType(RevealerTransitionType.SLIDE_LEFT); - setHalign(GtkAlign.END); + setTransitionType(RevealerTransitionType.SlideLeft); + setHalign(Align.End); } else { - setTransitionType(RevealerTransitionType.SLIDE_RIGHT); - setHalign(GtkAlign.START); + setTransitionType(RevealerTransitionType.SlideRight); + setHalign(Align.Start); } } @@ -288,40 +328,47 @@ public: super(); gsSettings = new GSettings(SETTINGS_ID); - gsSettings.addOnChanged(delegate(string key, GSettings) { + gsSettings.connectChanged(null, delegate(string key) { if (key == SETTINGS_SIDEBAR_RIGHT) { setSidebarPosition(); } }); - addOnButtonPress(&onButtonPress); - addOnKeyRelease(&onKeyRelease); - addOnKeyPress(&onKeyPress); + connectButtonPressEvent(delegate(EventButton event) { + return onButtonPress(event); + }); + connectKeyReleaseEvent(delegate(EventKey event) { + return onKeyRelease(event); + }); + connectKeyPressEvent(delegate(EventKey event) { + return onKeyPress(event); + }); setHexpand(false); setVexpand(true); - setValign(GtkAlign.FILL); + setValign(Align.Fill); setSidebarPosition(); lbSessions = new ListBox(); lbSessions.setCanFocus(true); - lbSessions.setSelectionMode(SelectionMode.BROWSE); + lbSessions.setSelectionMode(SelectionMode.Browse); lbSessions.getStyleContext().addClass("tilix-session-sidebar"); - lbSessions.addOnRowActivated(&onRowActivated); - //lbSessions.addOnKeynavFailed(&onKeyNavFailed); + lbSessions.connectRowActivated(&onRowActivated); + //lbSessions.connectKeynavFailed(&onKeyNavFailed); - sw = new ScrolledWindow(lbSessions); - sw.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); - sw.setShadowType(ShadowType.IN); + sw = new ScrolledWindow(); + sw.add(lbSessions); + sw.setPolicy(PolicyType.Never, PolicyType.Automatic); + sw.setShadowType(ShadowType.In); - sw.addOnUnmap(delegate(Widget) { + sw.connectUnmap(delegate() { if (hasGrab()) { grabRemove(); trace("** Unmapped, Removing Sidebar Grab"); } hide(); }); - sw.addOnMap(delegate(Widget) { + sw.connectMap(delegate(Widget w) { // Need to give some time for adjustment values to catch up threadsAddTimeoutDelegate(20, delegate() { //Make sure row is visible @@ -334,7 +381,7 @@ public: } return false; }); - }, ConnectFlags.AFTER); + }, Yes.After); add(sw); } @@ -352,7 +399,7 @@ public: blockSelectedHandler = false; } - SideBarRow[] rows = gx.gtk.util.getChildren!SideBarRow(lbSessions, false); + SideBarRow[] rows = gx.gtk.util.findChildren!SideBarRow(lbSessions, false); ulong maxSessions = min(rows.length, sessions.length); for (size_t i; i < maxSessions; i++) { @@ -412,6 +459,19 @@ public: } } + void reveal(bool revealChild) { + setRevealChild(revealChild); + } + + void showSessionSwitcher() { + setRevealChild(true); + } + + void updateNotifications(SessionNotification[string] notifications) { + // Update notification badges for sessions + // Placeholder implementation + } + //Events public: @@ -452,6 +512,31 @@ public: * x, y - Coordinates where detach was requested */ GenericEvent!(string, int, int) onSessionDetach; + + /** + * Event when a session file is selected from recent files + */ + GenericEvent!(string) onFileSelected; + + /** + * Event when a session file should be removed from recent files + */ + GenericEvent!(string) onFileRemoved; + + /** + * Event when a session is selected to be opened + */ + GenericEvent!(string) onOpenSelected; + + /** + * Event when a session should be attached + */ + GenericEvent!(string) onSessionAttach; + + /** + * Event that requests session reorder + */ + GenericEvent!(string, string, bool, CumulativeResult!bool) onSessionReorder; } private: @@ -477,7 +562,7 @@ private: AspectFrame wrapWidget(Widget widget, string cssClass) { AspectFrame af = new AspectFrame(null, 0.5, 0.5, 1.0, false); - af.setShadowType(ShadowType.NONE); + af.setShadowType(ShadowType.None); if (cssClass.length > 0) { af.getStyleContext().addClass(cssClass); } @@ -489,12 +574,13 @@ private: Overlay overlay = new Overlay(); setAllMargins(overlay, 2); Pixbuf pb = getWidgetImage(session.drawable, 0.20, width, height); - img = new Image(pb); + img = Image.newFromPixbuf(pb); scope(exit) { pb.destroy(); } - Frame imgframe = new Frame(img, null); - imgframe.setShadowType(ShadowType.IN); + Frame imgframe = new Frame(null); + imgframe.add(img); + imgframe.setShadowType(ShadowType.In); overlay.add(imgframe); //Create Notification and Session Numbers Grid grid = new Grid(); @@ -523,28 +609,28 @@ private: lblName = new Label(""); lblName.setMarginLeft(2); lblName.setMarginRight(2); - lblName.setEllipsize(PangoEllipsizeMode.END); - lblName.setHalign(GtkAlign.CENTER); + lblName.setEllipsize(EllipsizeMode.End); + lblName.setHalign(Align.Center); lblName.setHexpand(true); lblName.setSensitive(false); lblName.getStyleContext().addClass("tilix-session-name"); - Box b = new Box(Orientation.HORIZONTAL, 4); + Box b = new Box(Orientation.Horizontal, 4); b.setHexpand(true); b.add(lblName); grid.attach(b, 1, 2, 1, 1); lblIndex = new Label(format("%d", 0)); - lblIndex.setValign(GtkAlign.END); + lblIndex.setValign(Align.End); lblIndex.setVexpand(false); setAllMargins(lblIndex, 4); lblIndex.setWidthChars(2); grid.attach(wrapWidget(lblIndex, "tilix-session-index"), 2, 2, 1, 1); //Add Close Button - btnClose = new Button("window-close-symbolic", IconSize.MENU); + btnClose = Button.newFromIconName("window-close-symbolic", IconSize.Menu); btnClose.getStyleContext().addClass("tilix-sidebar-close-button"); btnClose.setTooltipText(_("Close")); - btnClose.setRelief(ReliefStyle.NONE); + btnClose.setRelief(ReliefStyle.None); btnClose.setFocusOnClick(false); grid.attach(btnClose, 2, 0, 1, 1); @@ -554,18 +640,18 @@ private: eb = new EventBox(); eb.add(overlay); // Drag and Drop - TargetEntry[] targets = [new TargetEntry(SESSION_DND, TargetFlags.SAME_APP, 0)]; - eb.dragSourceSet(ModifierType.BUTTON1_MASK, targets, DragAction.MOVE); - eb.dragDestSet(DestDefaults.ALL, targets, DragAction.MOVE); - ebEventHandlerId ~= eb.addOnDragDataGet(&onRowDragDataGet); - ebEventHandlerId ~= eb.addOnDragDataReceived(&onRowDragDataReceived); - ebEventHandlerId ~= eb.addOnDragBegin(&onRowDragBegin); - ebEventHandlerId ~= eb.addOnDragEnd(&onRowDragEnd); - ebEventHandlerId ~= eb.addOnDragFailed(&onRowDragFailed); + TargetEntry[] targets = [new TargetEntry(SESSION_DND, TargetFlags.SameApp, 0)]; + eb.dragSourceSet(ModifierType.Button1Mask, targets, DragAction.Move); + eb.dragDestSet(DestDefaults.All, targets, DragAction.Move); + ebEventHandlerId ~= eb.connectDragDataGet(&onRowDragDataGet); + ebEventHandlerId ~= eb.connectDragDataReceived(&onRowDragDataReceived); + ebEventHandlerId ~= eb.connectDragBegin(&onRowDragBegin); + ebEventHandlerId ~= eb.connectDragEnd(&onRowDragEnd); + ebEventHandlerId ~= eb.connectDragFailed(&onRowDragFailed); add(eb); - closeButtonHandler = btnClose.addOnClicked(delegate(Button) { + closeButtonHandler = btnClose.connectClicked(delegate() { if (sidebar !is null) sidebar.removeSession(_sessionUUID); }); } @@ -598,7 +684,7 @@ private: void onRowDragBegin(DragContext dc, Widget widget) { isRootWindow = false; - Image image = new Image(getWidgetImage(this, 1.00)); + Image image = Image.newFromPixbuf(getWidgetImage(this, 1.00)); image.show(); if (dragImage !is null) { @@ -607,9 +693,9 @@ private: dragImage = null; } - dragImage = new Window(GtkWindowType.POPUP); + dragImage = new Window(GtkWindowType.Popup); dragImage.add(image); - DragAndDrop.dragSetIconWidget(dc, dragImage, 0, 0); + dragSetIconWidget(dc, dragImage, 0, 0); } void onRowDragEnd(DragContext dc, Widget widget) { @@ -621,7 +707,7 @@ private: dragImage = null; // Under Wayland needed to fix cursor sticking due to - // GtkD holding reference to GTK DragReference + // GTK binding holding reference to GTK DragContext dc.destroy(); } @@ -649,22 +735,23 @@ private: } void onRowDragDataGet(DragContext dc, SelectionData data, uint info, uint time, Widget widget) { - GdkAtom gdkAtom = data.getTarget(); - string name = gdk.Atom.name(gdkAtom); - if (name == "application/x-rootwindow-drop") { + Atom targetAtom = data.getTarget(); + string atomName = targetAtom.name(); + if (atomName == "application/x-rootwindow-drop") { trace("onRowDragDataGet Root window drop"); isRootWindow = true; } else { - tracef("onRowDragDataGet atom: %s", name); + tracef("onRowDragDataGet atom: %s", atomName); isRootWindow = false; } - char[] buffer = (sessionUUID ~ '\0').dup; - data.set(intern(SESSION_DND, false), 8, buffer); + ubyte[] buffer = cast(ubyte[])(sessionUUID ~ '\0').dup; + data.set(Atom.intern(SESSION_DND, false), 8, buffer); } void onRowDragDataReceived(DragContext dc, int x, int y, SelectionData data, uint info, uint time, Widget widget) { - string sourceUUID = to!string(data.getDataWithLength()[0 .. $ - 1]); + ubyte[] rawData = data.getData(); + string sourceUUID = cast(string)(rawData[0 .. $ - 1]); tracef("Session UUID %s dropped", sourceUUID); sidebar.reorderSessions(sourceUUID, sessionUUID); } @@ -693,9 +780,9 @@ public: */ public void release() { foreach(id; ebEventHandlerId) { - Signals.handlerDisconnect(eb, id); + signalHandlerDisconnect(eb, id); } - Signals.handlerDisconnect(btnClose, closeButtonHandler); + signalHandlerDisconnect(btnClose, closeButtonHandler); this.sidebar = null; } diff --git a/source/gx/tilix/terminal/actions.d b/source/gx/tilix/terminal/actions.d index 4fd5eaf3e..8ec471494 100644 --- a/source/gx/tilix/terminal/actions.d +++ b/source/gx/tilix/terminal/actions.d @@ -44,4 +44,18 @@ enum ACTION_MONITOR_SILENCE = "monitor-silence"; enum ACTION_FILE_BROWSER = "file-browser"; enum ACTION_PREVIOUS_PROMPT = "previous-prompt"; enum ACTION_NEXT_PROMPT = "next-prompt"; -enum ACTION_TOGGLE_MARGIN = "toggle-margin"; \ No newline at end of file +enum ACTION_TOGGLE_MARGIN = "toggle-margin"; + +struct ActionInfo { + string name; +} + +// Actions that should be delegated from session to terminal +immutable ActionInfo[] terminalDelegatedActions = [ + ActionInfo(ACTION_COPY), + ActionInfo(ACTION_PASTE), + ActionInfo(ACTION_SELECT_ALL), + ActionInfo(ACTION_ZOOM_IN), + ActionInfo(ACTION_ZOOM_OUT), + ActionInfo(ACTION_ZOOM_NORMAL), +]; \ No newline at end of file diff --git a/source/gx/tilix/terminal/advpaste.d b/source/gx/tilix/terminal/advpaste.d index e111bf114..833bee22e 100644 --- a/source/gx/tilix/terminal/advpaste.d +++ b/source/gx/tilix/terminal/advpaste.d @@ -8,22 +8,28 @@ import std.experimental.logger; import std.format; import std.string; -import gdk.Event; -import gdk.Keysyms; - -import gio.Settings: GSettings = Settings; - -import gtk.Box; -import gtk.CheckButton; -import gtk.Dialog; -import gtk.Label; -import gtk.SpinButton; -import gtk.TextBuffer; -import gtk.TextTagTable; -import gtk.TextView; -import gtk.ScrolledWindow; -import gtk.Widget; -import gtk.Window; +import gdk.event : Event; +import gdk.event_key : EventKey; +// GID does not provide gdk.keysyms, define required constants locally +private enum GdkKeysyms { GDK_Return = 0xff0d, GDK_Escape = 0xff1b } + +import gio.settings: GSettings = Settings; +import gio.types : SettingsBindFlags; + +import gtk.box : Box; +import gtk.check_button : CheckButton; +import gtk.dialog : Dialog; +import gtk.label : Label; +import gtk.spin_button : SpinButton; +import gtk.text_buffer : TextBuffer; +import gtk.text_iter : TextIter; +import gtk.text_tag_table : TextTagTable; +import gtk.text_view : TextView; +import gtk.scrolled_window : ScrolledWindow; +import gtk.widget : Widget; +import gtk.window : Window; +import gtk.types : Align, DialogFlags, Orientation, PolicyType, ResponseType, ShadowType; +import gdk.types : ModifierType; import gx.i18n.l10n; @@ -62,31 +68,31 @@ private: setMarginBottom(18); } - Box b = new Box(Orientation.VERTICAL, 6); + Box b = new Box(Orientation.Vertical, 6); if (unsafe) { string[3] msg = getUnsafePasteMessage(); Label lblUnsafe = new Label("" ~ msg[0] ~ "\n" ~ msg[1] ~ "\n" ~ msg[2]); lblUnsafe.setUseMarkup(true); lblUnsafe.setLineWrap(true); b.add(lblUnsafe); - getWidgetForResponse(ResponseType.APPLY).getStyleContext().addClass("destructive-action"); + getWidgetForResponse(ResponseType.Apply).getStyleContext().addClass("destructive-action"); } buffer = new TextBuffer(new TextTagTable()); - buffer.setText(text); - TextView view = new TextView(buffer); - view.addOnKeyPress(delegate(Event event, Widget w) { - uint keyval; - event.getKeyval(keyval); - if (keyval == GdkKeysyms.GDK_Return && (event.key.state & GdkModifierType.CONTROL_MASK)) { - response(GtkResponseType.APPLY); + buffer.setText(text, cast(int)text.length); + TextView view = TextView.newWithBuffer(buffer); + view.connectKeyPressEvent(delegate(EventKey event) { + uint keyval = event.keyval; + if (keyval == GdkKeysyms.GDK_Return && (event.state & ModifierType.ControlMask)) { + response(ResponseType.Apply); return true; } return false; }); - ScrolledWindow sw = new ScrolledWindow(view); - sw.setShadowType(ShadowType.ETCHED_IN); - sw.setPolicy(PolicyType.AUTOMATIC, PolicyType.AUTOMATIC); + ScrolledWindow sw = new ScrolledWindow(); + sw.add(view); + sw.setShadowType(ShadowType.EtchedIn); + sw.setPolicy(PolicyType.Automatic, PolicyType.Automatic); sw.setHexpand(true); sw.setVexpand(true); sw.setSizeRequest(400, 140); @@ -95,32 +101,34 @@ private: Label lblTransform = new Label(format("%s", _("Transform"))); lblTransform.setUseMarkup(true); - lblTransform.setHalign(GtkAlign.START); + lblTransform.setHalign(Align.Start); lblTransform.setMarginTop(6); b.add(lblTransform); //Tabs to Spaces - Box bTabs = new Box(Orientation.HORIZONTAL, 6); - cbTabsToSpaces = new CheckButton(_("Convert spaces to tabs")); - gsSettings.bind(SETTINGS_ADVANCED_PASTE_REPLACE_TABS_KEY, cbTabsToSpaces, "active", GSettingsBindFlags.DEFAULT); + Box bTabs = new Box(Orientation.Horizontal, 6); + cbTabsToSpaces = CheckButton.newWithLabel(_("Convert spaces to tabs")); + gsSettings.bind(SETTINGS_ADVANCED_PASTE_REPLACE_TABS_KEY, cbTabsToSpaces, "active", SettingsBindFlags.Default); bTabs.add(cbTabsToSpaces); - sbTabWidth = new SpinButton(0, 32, 1); - gsSettings.bind(SETTINGS_ADVANCED_PASTE_SPACE_COUNT_KEY, sbTabWidth.getAdjustment(), "value", GSettingsBindFlags.DEFAULT); - gsSettings.bind(SETTINGS_ADVANCED_PASTE_REPLACE_TABS_KEY, sbTabWidth, "sensitive", GSettingsBindFlags.DEFAULT); + sbTabWidth = SpinButton.newWithRange(0, 32, 1); + gsSettings.bind(SETTINGS_ADVANCED_PASTE_SPACE_COUNT_KEY, sbTabWidth.getAdjustment(), "value", SettingsBindFlags.Default); + gsSettings.bind(SETTINGS_ADVANCED_PASTE_REPLACE_TABS_KEY, sbTabWidth, "sensitive", SettingsBindFlags.Default); bTabs.add(sbTabWidth); b.add(bTabs); - cbConvertCRLF = new CheckButton(_("Convert CRLF and CR to LF")); - gsSettings.bind(SETTINGS_ADVANCED_PASTE_REPLACE_CRLF_KEY, cbConvertCRLF, "active", GSettingsBindFlags.DEFAULT); + cbConvertCRLF = CheckButton.newWithLabel(_("Convert CRLF and CR to LF")); + gsSettings.bind(SETTINGS_ADVANCED_PASTE_REPLACE_CRLF_KEY, cbConvertCRLF, "active", SettingsBindFlags.Default); b.add(cbConvertCRLF); getContentArea().add(b); } string transform() { - string text = buffer.getText(); + TextIter startIter, endIter; + buffer.getBounds(startIter, endIter); + string text = buffer.getText(startIter, endIter, false); if (gsSettings.getBoolean(SETTINGS_ADVANCED_PASTE_REPLACE_TABS_KEY)) { text = text.detab(gsSettings.getInt(SETTINGS_ADVANCED_PASTE_SPACE_COUNT_KEY)); } @@ -134,9 +142,13 @@ private: public: this(Window parent, string text, bool unsafe) { - super(_("Advanced Paste"), parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [_("Paste"), _("Cancel")], [GtkResponseType.APPLY, GtkResponseType.CANCEL]); + super(); + setTitle(_("Advanced Paste")); setTransientFor(parent); - setDefaultResponse(GtkResponseType.APPLY); + setModal(true); + addButton(_("Paste"), ResponseType.Apply); + addButton(_("Cancel"), ResponseType.Cancel); + setDefaultResponse(ResponseType.Apply); gsSettings = new GSettings(SETTINGS_ID); createUI(text, unsafe); } diff --git a/source/gx/tilix/terminal/exvte.d b/source/gx/tilix/terminal/exvte.d index e073eef43..249987b97 100644 --- a/source/gx/tilix/terminal/exvte.d +++ b/source/gx/tilix/terminal/exvte.d @@ -8,16 +8,21 @@ import core.sys.posix.unistd; import std.algorithm; import std.experimental.logger; +import std.typecons : Flag, No, Yes; -import gdk.Event; -import gdk.RGBA; +import gdk.event; +import gdk.rgba; -import gobject.Signals; +import gobject.global : signalLookup; +import gobject.c.functions : g_signal_connect_data; +import gobject.c.types : GCallback, GClosure, GClosureNotify, GConnectFlags, GObject, GType; -import glib.Str; +import std.string : fromStringz; +import glib.c.types : gulong; -import vte.Terminal; -import vtec.vtetypes; +import vte.terminal; +import vte.c.types; +import vte.c.functions : vte_terminal_get_type; import gx.tilix.constants; import gx.tilix.terminal.util; @@ -28,7 +33,7 @@ enum TerminalScreen { }; /** - * Extends default GtKD VTE widget to support various patches + * Extends default GID VTE widget to support various patches * which provide additional features when available. */ class ExtendedVTE : Terminal { @@ -41,8 +46,8 @@ public: /** * Sets our main struct and passes it to the parent class. */ - this(VteTerminal* vteTerminal, bool ownedRef = false) { - super(vteTerminal, ownedRef); + this(VteTerminal* vteTerminal, Flag!"Take" take = No.Take) { + super(cast(void*) vteTerminal, take); } /** @@ -67,8 +72,8 @@ public: { void delegate(string, string, Terminal) dlg; gulong handlerId; - ConnectFlags flags; - this(void delegate(string, string, Terminal) dlg, gulong handlerId, ConnectFlags flags) + GConnectFlags flags; + this(void delegate(string, string, Terminal) dlg, gulong handlerId, GConnectFlags flags) { this.dlg = dlg; this.handlerId = handlerId; @@ -85,12 +90,13 @@ public: * summary = The summary * bod = Extra optional text */ - gulong addOnNotificationReceived(void delegate(string, string, Terminal) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) + gulong connectNotificationReceived(void delegate(string, string, Terminal) dlg, GConnectFlags connectFlags=cast(GConnectFlags)0) { - if (Signals.lookup("notification-received", getType()) != 0) { + GType gtype = vte_terminal_get_type(); + if (signalLookup("notification-received", gtype) != 0) { onNotificationReceivedListeners ~= new OnNotificationReceivedDelegateWrapper(dlg, 0, connectFlags); - onNotificationReceivedListeners[onNotificationReceivedListeners.length - 1].handlerId = Signals.connectData( - this, + onNotificationReceivedListeners[onNotificationReceivedListeners.length - 1].handlerId = g_signal_connect_data( + cast(GObject*) _cPtr, "notification-received", cast(GCallback)&callBackNotificationReceived, cast(void*)onNotificationReceivedListeners[onNotificationReceivedListeners.length - 1], @@ -104,7 +110,7 @@ public: extern(C) static void callBackNotificationReceived(VteTerminal* terminalStruct, char* summary, char* bod,OnNotificationReceivedDelegateWrapper wrapper) { - wrapper.dlg(Str.toString(summary), Str.toString(bod), wrapper.outer); + wrapper.dlg(fromStringz(summary).idup, fromStringz(bod).idup, wrapper.outer); } extern(C) static void callBackNotificationReceivedDestroy(OnNotificationReceivedDelegateWrapper wrapper, GClosure* closure) @@ -129,8 +135,8 @@ public: { void delegate(int, Terminal) dlg; gulong handlerId; - ConnectFlags flags; - this(void delegate(int, Terminal) dlg, gulong handlerId, ConnectFlags flags) + GConnectFlags flags; + this(void delegate(int, Terminal) dlg, gulong handlerId, GConnectFlags flags) { this.dlg = dlg; this.handlerId = handlerId; @@ -140,12 +146,13 @@ public: protected OnTerminalScreenChangedDelegateWrapper[] onTerminalScreenChangedListeners; /** */ - gulong addOnTerminalScreenChanged(void delegate(int, Terminal) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) + gulong connectTerminalScreenChanged(void delegate(int, Terminal) dlg, GConnectFlags connectFlags=cast(GConnectFlags)0) { - if (Signals.lookup("terminal-screen-changed", getType()) != 0) { + GType gtype = vte_terminal_get_type(); + if (signalLookup("terminal-screen-changed", gtype) != 0) { onTerminalScreenChangedListeners ~= new OnTerminalScreenChangedDelegateWrapper(dlg, 0, connectFlags); - onTerminalScreenChangedListeners[onTerminalScreenChangedListeners.length - 1].handlerId = Signals.connectData( - this, + onTerminalScreenChangedListeners[onTerminalScreenChangedListeners.length - 1].handlerId = g_signal_connect_data( + cast(GObject*) _cPtr, "terminal-screen-changed", cast(GCallback)&callBackTerminalScreenChanged, cast(void*)onTerminalScreenChangedListeners[onTerminalScreenChangedListeners.length - 1], @@ -181,16 +188,16 @@ public: } public bool getDisableBGDraw() { - return vte_terminal_get_disable_bg_draw(vteTerminal) != 0; + return vte_terminal_get_disable_bg_draw(cast(VteTerminal*) _cPtr) != 0; } public void setDisableBGDraw(bool isDisabled) { - vte_terminal_set_disable_bg_draw(vteTerminal, isDisabled); + vte_terminal_set_disable_bg_draw(cast(VteTerminal*) _cPtr, isDisabled); } static if (COMPILE_VTE_BACKGROUND_COLOR) { public void getColorBackgroundForDraw(RGBA background) { - vte_terminal_get_color_background_for_draw(vteTerminal, background is null? null: background.getRGBAStruct()); + vte_terminal_get_color_background_for_draw(cast(VteTerminal*) _cPtr, background is null ? null : cast(GdkRGBA*) background._cPtr); } } @@ -213,7 +220,7 @@ static if (COMPILE_VTE_BACKGROUND_COLOR) { private: -import gtkc.Loader; +import core.sys.posix.dlfcn; import vte.c.functions; __gshared extern(C) { @@ -232,11 +239,18 @@ static if (COMPILE_VTE_BACKGROUND_COLOR) { alias vte_terminal_get_color_background_for_draw = c_vte_terminal_get_color_background_for_draw; } +private void* linkFunc(void* handle, const(char)* name) { + return dlsym(handle, name); +} + shared static this() { - Linker.link(vte_terminal_get_disable_bg_draw, "vte_terminal_get_disable_bg_draw", LIBRARY_VTE); - Linker.link(vte_terminal_set_disable_bg_draw, "vte_terminal_set_disable_bg_draw", LIBRARY_VTE); + void* handle = dlopen(null, RTLD_NOW); + if (handle !is null) { + c_vte_terminal_get_disable_bg_draw = cast(typeof(c_vte_terminal_get_disable_bg_draw)) linkFunc(handle, "vte_terminal_get_disable_bg_draw"); + c_vte_terminal_set_disable_bg_draw = cast(typeof(c_vte_terminal_set_disable_bg_draw)) linkFunc(handle, "vte_terminal_set_disable_bg_draw"); - static if (COMPILE_VTE_BACKGROUND_COLOR) { - Linker.link(vte_terminal_get_color_background_for_draw, "vte_terminal_get_color_background_for_draw", LIBRARY_VTE); - } + static if (COMPILE_VTE_BACKGROUND_COLOR) { + c_vte_terminal_get_color_background_for_draw = cast(typeof(c_vte_terminal_get_color_background_for_draw)) linkFunc(handle, "vte_terminal_get_color_background_for_draw"); + } + } } diff --git a/source/gx/tilix/terminal/layout.d b/source/gx/tilix/terminal/layout.d index 65358adc3..a0b16aed8 100644 --- a/source/gx/tilix/terminal/layout.d +++ b/source/gx/tilix/terminal/layout.d @@ -6,12 +6,13 @@ module gx.tilix.terminal.layout; import std.format; -import gtk.Dialog; -import gtk.Entry; -import gtk.Grid; -import gtk.Label; -import gtk.Version; -import gtk.Window; +import gtk.dialog : Dialog; +import gtk.entry : Entry; +import gtk.global : checkVersion; +import gtk.grid : Grid; +import gtk.label : Label; +import gtk.window : Window; +import gtk.types : Align, DialogFlags, ResponseType; import gx.i18n.l10n; import gx.gtk.vte; @@ -30,8 +31,13 @@ private: public: this(Window window) { - super(_("Layout Options"), window, DialogFlags.MODAL + DialogFlags.USE_HEADER_BAR, [_("OK"), _("Cancel")], [ResponseType.OK, ResponseType.CANCEL]); - setDefaultResponse(ResponseType.OK); + super(); + setTitle(_("Layout Options")); + setTransientFor(window); + setModal(true); + addButton(_("OK"), ResponseType.Ok); + addButton(_("Cancel"), ResponseType.Cancel); + setDefaultResponse(ResponseType.Ok); setTransientFor(window); setDefaultSize(400, -1); @@ -47,17 +53,17 @@ public: Label lblActive = new Label(format("%s", _("Active"))); lblActive.setUseMarkup(true); - lblActive.setHalign(GtkAlign.START); + lblActive.setHalign(Align.Start); grid.attach(lblActive, 0, row, 2, 1); row++; Label lblTitle = new Label(_("Title")); - lblTitle.setHalign(GtkAlign.END); + lblTitle.setHalign(Align.End); grid.attach(lblTitle, 0, row, 1, 1); eTitle = new Entry(); eTitle.setWidthChars(20); eTitle.setHexpand(true); - if (Version.checkVersion(3,16, 0).length == 0) { + if (checkVersion(3,16, 0).length == 0) { grid.attach(createTitleEditHelper(eTitle, TitleEditScope.TERMINAL), 1, row, 1, 1); } else { grid.attach(eTitle, 1, row, 1, 1); @@ -66,12 +72,12 @@ public: if (checkVTEFeature(TerminalFeature.DISABLE_BACKGROUND_DRAW)) { Label lblBadge = new Label(_("Badge")); - lblBadge.setHalign(GtkAlign.END); + lblBadge.setHalign(Align.End); grid.attach(lblBadge, 0, row, 1, 1); eBadge = new Entry(); eBadge.setHexpand(true); eBadge.setWidthChars(20); - if (Version.checkVersion(3,16, 0).length == 0) { + if (checkVersion(3,16, 0).length == 0) { grid.attach(createTitleEditHelper(eBadge, TitleEditScope.TERMINAL), 1, row, 1, 1); } else { grid.attach(eBadge, 1, row, 1, 1); @@ -81,13 +87,13 @@ public: Label lblLoad = new Label(format("%s", _("Session Load"))); lblLoad.setUseMarkup(true); - lblLoad.setHalign(GtkAlign.START); + lblLoad.setHalign(Align.Start); lblLoad.setMarginTop(6); grid.attach(lblLoad, 0, row, 2, 1); row++; Label lblCommand = new Label(_("Command")); - lblCommand.setHalign(GtkAlign.END); + lblCommand.setHalign(Align.End); grid.attach(lblCommand, 0, row, 1, 1); eCommand = new Entry(); @@ -105,11 +111,11 @@ public: getContentArea().add(grid); } - @property string title() { + @property override string title() { return eTitle.getText(); } - @property void title(string value) { + @property override void title(string value) { if (value.length > 0) { eTitle.setText(value); } diff --git a/source/gx/tilix/terminal/monitor.d b/source/gx/tilix/terminal/monitor.d index c25cfb9c0..02f73bc7d 100644 --- a/source/gx/tilix/terminal/monitor.d +++ b/source/gx/tilix/terminal/monitor.d @@ -12,7 +12,7 @@ import std.datetime; import std.experimental.logger; import std.parallelism; -import vtec.vtetypes; +import vte.c.types; import gx.i18n.l10n; import gx.gtk.threads; diff --git a/source/gx/tilix/terminal/password.d b/source/gx/tilix/terminal/password.d index 9dc2bca47..bc259d47f 100644 --- a/source/gx/tilix/terminal/password.d +++ b/source/gx/tilix/terminal/password.d @@ -12,46 +12,59 @@ import std.process; import std.string; import std.uuid; -import gdk.Event; -import gdk.Keysyms; - -import gobject.ObjectG; - -import gio.Cancellable; -import gio.Settings: GSettings=Settings; -import gio.SimpleAsyncResult; - -import glib.GException; -import glib.HashTable; -import glib.ListG; - -import gtk.Box; -import gtk.Button; -import gtk.CellRendererText; -import gtk.CheckButton; -import gtk.Dialog; -import gtk.EditableIF; -import gtk.Entry; -import gtk.Grid; -import gtk.Label; -import gtk.ListStore; -import gtk.TreeIter; -import gtk.TreePath; -import gtk.TreeView; -import gtk.TreeViewColumn; -import gtk.ScrolledWindow; -import gtk.SearchEntry; -import gtk.Widget; -import gtk.Window; - -import secret.Collection; -import secret.Item; -import secret.Schema; -import secret.Secret; -import secret.Service; -import secret.Value; - -import gx.gtk.util; +import gdk.event : Event; +import gdk.event_key : EventKey; +// GID does not provide gdk.keysyms, define required constants locally +private enum GdkKeysyms { GDK_Return = 0xff0d, GDK_Escape = 0xff1b } + +import gobject.object : ObjectWrap; +import gobject.c.types : GObject; +import gobject.value : Value; + +import gio.async_result : AsyncResult; +import gio.cancellable : Cancellable; +import gio.c.types : GAsyncResult; +import gio.settings: GSettings=Settings; +import gio.types : SettingsBindFlags; + +import glib.error : ErrorWrap; + +import gtk.box : Box; +import gtk.button : Button; +import gtk.cell_renderer_text : CellRendererText; +import gtk.check_button : CheckButton; +import gtk.dialog : Dialog; +import gtk.editable : Editable; +import gtk.entry : Entry; +import gtk.grid : Grid; +import gtk.label : Label; +import gtk.list_store : ListStore; +import gtk.tree_iter : TreeIter; +import gtk.tree_path : TreePath; +import gtk.tree_view : TreeView; +import gtk.tree_view_column : TreeViewColumn; +import gtk.scrolled_window : ScrolledWindow; +import gtk.search_entry : SearchEntry; +import gtk.widget : Widget; +import gtk.window : Window; +import gtk.types : Align, DialogFlags, Orientation, PolicyType, ResponseType, ShadowType; + +import secret.collection : Collection; +import secret.item : Item; +import secret.schema : Schema; +import secret.global : passwordStoreSync, passwordClearSync, passwordLookupSync; +import secret.service : Service; +import secret.value : SecretValue = Value; +import secret.types : SchemaFlags, ServiceFlags, CollectionFlags; +import secret.c.types : SecretSchema, SecretSchemaAttribute, SecretSchemaAttributeType, SecretSchemaFlags; +import secret.c.functions : secret_schema_newv; + +import glib.c.types : GHashTable; +import glib.c.functions : g_hash_table_new, g_hash_table_insert; + +import std.typecons : Flag, Yes; + +import gx.gtk.util : GTypes, selectRow, getValueString, getSelectedIter; import gx.i18n.l10n; import gx.tilix.preferences; @@ -73,7 +86,7 @@ private: enum DEFAULT_COLLECTION = "default"; - HashTable EMPTY_ATTRIBUTES; + string[string] EMPTY_ATTRIBUTES; SearchEntry se; TreeView tv; @@ -91,9 +104,9 @@ private: Cancellable[string] pending; // Null terminated strings we need to keep a reference for C async methods - immutable(char*) attrDescription; - immutable(char*) attrID; - immutable(char*) descriptionValue; + + + // List of items string[][] rows; @@ -106,100 +119,108 @@ private: setMarginBottom(18); } - Box b = new Box(Orientation.VERTICAL, 6); + Box b = new Box(Orientation.Vertical, 6); se = new SearchEntry(); - se.addOnSearchChanged(delegate(SearchEntry) { + se.connectSearchChanged(delegate() { filterEntries(); }); - se.addOnKeyPress(delegate(Event event, Widget w) { - uint keyval; - if (event.getKeyval(keyval)) { - if (keyval == GdkKeysyms.GDK_Escape) { - response = ResponseType.CANCEL; - return true; - } - if (keyval == GdkKeysyms.GDK_Return) { - response = ResponseType.APPLY; - return true; - } + se.connectKeyPressEvent(delegate(EventKey event) { + uint keyval = event.keyval; + if (keyval == GdkKeysyms.GDK_Escape) { + response(ResponseType.Cancel); + return true; + } + if (keyval == GdkKeysyms.GDK_Return) { + response(ResponseType.Apply); + return true; } return false; }); b.add(se); - Box bList = new Box(Orientation.HORIZONTAL, 6); + Box bList = new Box(Orientation.Horizontal, 6); - ls = new ListStore([GType.STRING, GType.STRING]); + ls = ListStore.new_([GTypes.STRING, GTypes.STRING]); - tv = new TreeView(ls); + tv = new TreeView(); + tv.setModel(ls); tv.setHeadersVisible(false); - TreeViewColumn column = new TreeViewColumn(_("Name"), new CellRendererText(), "text", COLUMN_NAME); + auto crt1 = new CellRendererText(); + TreeViewColumn column = new TreeViewColumn(); + column.setTitle(_("Name")); + column.packStart(crt1, true); + column.addAttribute(crt1, "text", COLUMN_NAME); column.setMinWidth(300); tv.appendColumn(column); - column = new TreeViewColumn(_("ID"), new CellRendererText(), "text", COLUMN_NAME); - column.setVisible(false); - tv.appendColumn(column); - - tv.addOnCursorChanged(delegate(TreeView) { + auto crt2 = new CellRendererText(); + TreeViewColumn column2 = new TreeViewColumn(); + column2.setTitle(_("ID")); + column2.packStart(crt2, true); + column2.addAttribute(crt2, "text", COLUMN_ID); + column2.setVisible(false); + tv.appendColumn(column2); + + tv.connectCursorChanged(delegate() { updateUI(); }); - tv.addOnRowActivated(delegate(TreePath, TreeViewColumn, TreeView) { - response(ResponseType.APPLY); + tv.connectRowActivated(delegate(TreePath p, TreeViewColumn c) { + response(ResponseType.Apply); }); - ScrolledWindow sw = new ScrolledWindow(tv); - sw.setShadowType(ShadowType.ETCHED_IN); - sw.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + ScrolledWindow sw = new ScrolledWindow(); + sw.add(tv); + sw.setShadowType(ShadowType.EtchedIn); + sw.setPolicy(PolicyType.Never, PolicyType.Automatic); sw.setHexpand(true); sw.setVexpand(true); sw.setSizeRequest(-1, 200); bList.add(sw); - Box bButtons = new Box(Orientation.VERTICAL, 6); - Button btnNew = new Button(_("New")); - btnNew.addOnClicked(delegate(Button) { - PasswordDialog pd = new PasswordDialog(this); + Box bButtons = new Box(Orientation.Vertical, 6); + Button btnNew = Button.newWithLabel(_("New")); + btnNew.connectClicked(delegate() { + PasswordDialog pd = new PasswordDialog(cast(Window) this); scope (exit) {pd.destroy();} pd.showAll(); - if (pd.run() == ResponseType.OK) { - SecretSchema* ss = schema.getSchemaStruct(); - trace("Schema name is " ~ to!string(ss.name)); + if (pd.run() == ResponseType.Ok) { tracef("Storing password, label=%s",pd.label); - Cancellable c = new Cancellable(); - //We could potentially have many password operations on the go, use random key string uuid = randomUUID().toString(); - pending[uuid] = c; - import gtkc.glib; - HashTable attributes = new HashTable(g_str_hash, g_str_equal); - immutable(char*) uuidz = toStringz(uuid); - attributes.insert(cast(void*)attrID, cast(void*)uuidz); - attributes.insert(cast(void*)attrDescription, cast(void*)descriptionValue); - Secret.passwordStorev(schema, attributes, DEFAULT_COLLECTION, pd.label, pd.password, c, &passwordStoreCallback, this.getDialogStruct()); + + string[string] attributes; + attributes[ATTRIBUTE_ID] = uuid; + attributes[ATTRIBUTE_DESCRIPTION] = "Tilix Password"; + + try { + passwordStoreSync(schema, attributes, DEFAULT_COLLECTION, pd.label, pd.password, null); + reload(); + } catch (Exception e) { + trace("Error storing password: " ~ e.msg); + } } }); bButtons.add(btnNew); - Button btnEdit = new Button(_("Edit")); - btnEdit.addOnClicked(delegate(Button) { - TreeIter selected = tv.getSelectedIter(); + Button btnEdit = Button.newWithLabel(_("Edit")); + btnEdit.connectClicked(delegate() { + TreeIter selected = getSelectedIter(tv); if (selected) { - string id = ls.getValueString(selected, COLUMN_ID); - PasswordDialog pd = new PasswordDialog(this, ls.getValueString(selected, COLUMN_NAME), ""); + string id = getValueString(ls, selected, COLUMN_ID); + PasswordDialog pd = new PasswordDialog(cast(Window) this, getValueString(ls, selected, COLUMN_NAME), ""); scope(exit) {pd.destroy();} pd.showAll(); - if (pd.run() == ResponseType.OK) { - ListG list = collection.getItems(); - Item[] items = list.toArray!Item; + if (pd.run() == ResponseType.Ok) { + Item[] items = collection.getItems(); + foreach (item; items) { if (item.getSchemaName() == SCHEMA_NAME) { - string itemID = to!string(cast(char*)item.getAttributes().lookup(cast(void*)attrID)); + string itemID = item.getAttributes().get(ATTRIBUTE_ID, ""); trace("ItemID " ~ itemID); if (id == itemID) { trace("Modifying item..."); item.setLabelSync(pd.label, null); - item.setSecretSync(new Value(pd.password, pd.password.length, "text/plain"), null); + item.setSecretSync(new SecretValue(pd.password, pd.password.length, "text/plain"), null); reload(); break; } @@ -210,15 +231,15 @@ private: }); bButtons.add(btnEdit); - Button btnDelete = new Button(_("Delete")); - btnDelete.addOnClicked(delegate(Button) { - TreeIter selected = tv.getSelectedIter(); + Button btnDelete = Button.newWithLabel(_("Delete")); + btnDelete.connectClicked(delegate() { + TreeIter selected = getSelectedIter(tv); if (selected) { - string id = ls.getValueString(selected, COLUMN_ID); - HashTable ht = createHashTable(); - immutable(char*) idz = toStringz(id); - ht.insert(cast(void*)attrID, cast(void*)idz); - Secret.passwordClearvSync(schema, ht, null); + string id = getValueString(ls, selected, COLUMN_ID); + string[string] ht; + + ht[ATTRIBUTE_ID] = id; + passwordClearSync(schema, ht, null); foreach(index, row; rows) { if (row[1] == id) { std.algorithm.remove(rows, index); @@ -232,8 +253,8 @@ private: bList.add(bButtons); b.add(bList); - CheckButton cbIncludeEnter = new CheckButton(_("Include return character with password")); - gsSettings.bind(SETTINGS_PASSWORD_INCLUDE_RETURN_KEY, cbIncludeEnter, "active", GSettingsBindFlags.DEFAULT); + CheckButton cbIncludeEnter = CheckButton.newWithLabel(_("Include return character with password")); + gsSettings.bind(SETTINGS_PASSWORD_INCLUDE_RETURN_KEY, cbIncludeEnter, "active", SettingsBindFlags.Default); b.add(cbIncludeEnter); getContentArea().add(b); @@ -241,15 +262,16 @@ private: void filterEntries() { string selectedID; - TreeIter selected = tv.getSelectedIter(); - if (selected) selectedID = ls.getValueString(selected, COLUMN_ID); + TreeIter selected = getSelectedIter(tv); + if (selected) selectedID = getValueString(ls, selected, COLUMN_ID); selected = null; ls.clear(); foreach(row; rows) { if (se.getText().length ==0 || row[0].indexOf(se.getText()) >=0) { - TreeIter iter = ls.createIter(); - ls.setValue(iter, COLUMN_NAME, row[0]); - ls.setValue(iter, COLUMN_ID, row[1]); + TreeIter iter; + ls.append(iter); + ls.setValue(iter, COLUMN_NAME, new Value(row[0])); + ls.setValue(iter, COLUMN_ID, new Value(row[1])); if (row[1] == selectedID) selected = iter; } } @@ -258,13 +280,13 @@ private: } void loadEntries() { - ListG list = collection.getItems(); - if (list is null) return; - Item[] items = list.toArray!Item; + Item[] items = collection.getItems(); + if (items is null || items.length == 0) return; + rows.length = 0; foreach (item; items) { if (item.getSchemaName() == SCHEMA_NAME) { - string id = to!string(cast(char*)item.getAttributes().lookup(cast(void*)attrID)); + string id = item.getAttributes().get(ATTRIBUTE_ID, ""); rows ~= [item.getLabel(), id]; } } @@ -283,83 +305,73 @@ private: createService(); } - HashTable createHashTable() { - import gtkc.glib; - return new HashTable(g_str_hash, g_str_equal); + string[string] createHashTable() { + + string[string] ht; return ht; } void createSchema() { - HashTable ht = createHashTable(); - ht.insert(cast(void*)attrID, cast(void*)0); - ht.insert(cast(void*)attrDescription, cast(void*)0); - schema = new Schema(SCHEMA_NAME, SecretSchemaFlags.NONE, ht); + // Create the schema using C API since GID doesn't expose Schema constructors + // We need to create a GHashTable with attribute names -> types + import core.stdc.string : strlen; + import std.string : toStringz; + + GHashTable* ht = g_hash_table_new(null, null); + // Values in the hash table are the attribute types (cast to void*) + g_hash_table_insert(ht, cast(void*) toStringz(ATTRIBUTE_ID), cast(void*) SecretSchemaAttributeType.String); + g_hash_table_insert(ht, cast(void*) toStringz(ATTRIBUTE_DESCRIPTION), cast(void*) SecretSchemaAttributeType.String); + + SecretSchema* cSchema = secret_schema_newv(toStringz(SCHEMA_NAME), SecretSchemaFlags.None, ht); + schema = new Schema(cast(void*) cSchema, Yes.Take); } void createService() { Cancellable c = new Cancellable(); pending[PENDING_SERVICE] = c; - Service.get(SecretServiceFlags.OPEN_SESSION, c, &secretServiceCallback, this.getDialogStruct()); + // GID async methods use D delegates, no user data needed + Service.get(ServiceFlags.OpenSession, c, &onSecretServiceReady); } void createCollection() { Cancellable c = new Cancellable(); pending[PENDING_COLLECTION] = c; - Collection.forAlias(service, DEFAULT_COLLECTION, SecretCollectionFlags.LOAD_ITEMS, c, &collectionCallback, this.getDialogStruct()); + // GID async methods use D delegates, no user data needed + Collection.forAlias(service, DEFAULT_COLLECTION, CollectionFlags.LoadItems, c, &onCollectionReady); } void updateUI() { - setResponseSensitive(ResponseType.APPLY, tv.getSelectedIter() !is null); + setResponseSensitive(ResponseType.Apply, getSelectedIter(tv) !is null); } - extern(C) static void passwordStoreCallback(GObject* sourceObject, GAsyncResult* res, void* userData) { - trace("passwordCallback called"); + // GID-style async callback for Service.get + void onSecretServiceReady(ObjectWrap sourceObject, AsyncResult res) { + trace("secretServiceCallback called"); try { - Secret.passwordStoreFinish(new SimpleAsyncResult(cast(GSimpleAsyncResult*)res, false)); - PasswordManagerDialog pd = cast(PasswordManagerDialog) ObjectG.getDObject!(Dialog)(cast(GtkDialog*) userData, false); - if (pd !is null) { - trace("Re-loading entries"); - pd.reload(); + Service ss = Service.getFinish(res); + if (ss !is null) { + pending.remove(PENDING_SERVICE); + service = ss; + createCollection(); + trace("Retrieved secret service"); } - } catch (GException ge) { + } catch (ErrorWrap ge) { trace("Error occurred: " ~ ge.msg); return; } } - extern(C) static void collectionCallback(GObject* sourceObject, GAsyncResult* res, void* userData) { + // GID-style async callback for Collection.forAlias + void onCollectionReady(ObjectWrap sourceObject, AsyncResult res) { trace("collectionCallback called"); try { - Collection c = Collection.forAliasFinish(new SimpleAsyncResult(cast(GSimpleAsyncResult*)res, false)); + Collection c = Collection.forAliasFinish(res); if (c !is null) { - PasswordManagerDialog pd = cast(PasswordManagerDialog) ObjectG.getDObject!(Dialog)(cast(GtkDialog*) userData, false); - if (pd !is null) { - pd.pending.remove(PENDING_COLLECTION); - pd.collection = c; - pd.loadEntries(); - trace("Retrieved default collection"); - } - } - } catch (GException ge) { - trace("Error occurred: " ~ ge.msg); - return; - } - } - - extern(C) static void secretServiceCallback(GObject* sourceObject, GAsyncResult* res, void* userData) { - trace("secretServiceCallback called"); - try { - Service ss = Service.getFinish(new SimpleAsyncResult(cast(GSimpleAsyncResult*)res, false)); - if (ss !is null) { - PasswordManagerDialog pd = cast(PasswordManagerDialog) ObjectG.getDObject!(Dialog)(cast(GtkDialog*) userData, false); - if (pd !is null) { - pd.pending.remove(PENDING_SERVICE); - pd.service = ss; - pd.createCollection(); - trace("Retrieved secret service"); - } + pending.remove(PENDING_COLLECTION); + collection = c; + loadEntries(); + trace("Retrieved default collection"); } - - } catch (GException ge) { + } catch (ErrorWrap ge) { trace("Error occurred: " ~ ge.msg); return; } @@ -368,18 +380,23 @@ private: public: this(Window parent) { - super(_("Insert Password"), parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [_("Apply"), _("Cancel")], [GtkResponseType.APPLY, GtkResponseType.CANCEL]); + super(); + setTitle(_("Insert Password")); + setTransientFor(parent); + setModal(true); + addButton(_("Apply"), ResponseType.Apply); + addButton(_("Cancel"), ResponseType.Cancel); gsSettings = new GSettings(SETTINGS_ID); - setDefaultResponse(GtkResponseType.APPLY); - addOnDestroy(delegate(Widget) { + setDefaultResponse(ResponseType.Apply); + connectDestroy(delegate() { foreach(c; pending) { c.cancel(); } }); - EMPTY_ATTRIBUTES = createHashTable(); - attrID = toStringz(ATTRIBUTE_ID); - attrDescription = toStringz(ATTRIBUTE_DESCRIPTION); - descriptionValue = toStringz("Tilix Password"); + EMPTY_ATTRIBUTES = null; + + + trace("Retrieving secret service"); createSchema(); createUI(); @@ -387,18 +404,18 @@ public: } @property string password() { - TreeIter selected = tv.getSelectedIter(); + TreeIter selected = getSelectedIter(tv); if (selected) { - string id = ls.getValueString(selected, COLUMN_ID); + string id = getValueString(ls, selected, COLUMN_ID); trace("Getting password for " ~ id); - HashTable ht = createHashTable(); - immutable(char*) idz = toStringz(id); - ht.insert(cast(void*)attrID, cast(void*)idz); - string password = Secret.passwordLookupvSync(schema, ht, null); + string[string] ht; + + ht[ATTRIBUTE_ID] = id; + string pwd = passwordLookupSync(schema, ht, null); if (gsSettings.getBoolean(SETTINGS_PASSWORD_INCLUDE_RETURN_KEY)) { - password ~= '\n'; + pwd ~= '\n'; } - return password; + return pwd; } else { return null; } @@ -429,7 +446,7 @@ private: int row = 0; // Name (i.e. Label in libsecret parlance) lblName = new Label(_("Name")); - lblName.setHalign(GtkAlign.END); + lblName.setHalign(Align.End); grid.attach(lblName, 0, row, 1, 1); eLabel = new Entry(); eLabel.setWidthChars(40); @@ -439,7 +456,7 @@ private: //Password lblPassword = new Label(_("Password")); - lblPassword.setHalign(GtkAlign.END); + lblPassword.setHalign(Align.End); grid.attach(lblPassword, 0, row, 1, 1); ePassword = new Entry(); ePassword.setVisibility(false); @@ -449,7 +466,7 @@ private: //Confirm Password lblRepeatPwd = new Label(_("Confirm Password")); - lblRepeatPwd.setHalign(GtkAlign.END); + lblRepeatPwd.setHalign(Align.End); grid.attach(lblRepeatPwd, 0, row, 1, 1); eConfirmPassword = new Entry(); eConfirmPassword.setVisibility(false); @@ -460,7 +477,7 @@ private: lblMatch = new Label("Password does not match confirmation"); lblMatch.setSensitive(false); lblMatch.setNoShowAll(true); - lblMatch.setHalign(GtkAlign.CENTER); + lblMatch.setHalign(Align.Center); grid.attach(lblMatch, 1, row, 1, 1); with (getContentArea()) { @@ -471,17 +488,17 @@ private: add(grid); } updateUI(); - eLabel.addOnChanged(&entryChanged); - ePassword.addOnChanged(&entryChanged); - eConfirmPassword.addOnChanged(&entryChanged); + eLabel.connectChanged(&entryChanged); + ePassword.connectChanged(&entryChanged); + eConfirmPassword.connectChanged(&entryChanged); } - void entryChanged(EditableIF) { + void entryChanged(Editable) { updateUI(); } void updateUI() { - setResponseSensitive(GtkResponseType.OK, eLabel.getText().length > 0 && ePassword.getText().length > 0 && ePassword.getText() == eConfirmPassword.getText()); + setResponseSensitive(ResponseType.Ok, eLabel.getText().length > 0 && ePassword.getText().length > 0 && ePassword.getText() == eConfirmPassword.getText()); if (ePassword.getText() != eConfirmPassword.getText()) { lblMatch.show(); } else { @@ -490,8 +507,13 @@ private: } this(Window parent, string title) { - super(title, parent, GtkDialogFlags.MODAL + GtkDialogFlags.USE_HEADER_BAR, [_("OK"), _("Cancel")], [GtkResponseType.OK, GtkResponseType.CANCEL]); - setDefaultResponse(GtkResponseType.OK); + super(); + setTitle(title); + setTransientFor(parent); + setModal(true); + addButton(_("OK"), ResponseType.Ok); + addButton(_("Cancel"), ResponseType.Cancel); + setDefaultResponse(ResponseType.Ok); } public: diff --git a/source/gx/tilix/terminal/regex.d b/source/gx/tilix/terminal/regex.d index ffb9ea090..a9146a218 100644 --- a/source/gx/tilix/terminal/regex.d +++ b/source/gx/tilix/terminal/regex.d @@ -40,14 +40,14 @@ module gx.tilix.terminal.regex; import std.conv; import std.string; -import glib.MatchInfo; -import glib.Regex : GRegex = Regex; +import glib.match_info; +import glib.regex : GRegex = Regex; -import gtkc.glibtypes; +import glib.c.types; import gx.gtk.vte; -import vte.Regex: VRegex = Regex; +import vte.regex: VRegex = Regex; import gx.tilix.constants; @@ -214,8 +214,8 @@ immutable VRegex[URL_REGEX_PATTERNS.length] compiledVRegex; GRegex compileGRegex(TerminalRegex regex) { if (regex.pattern.length == 0) return null; - GRegexCompileFlags flags = GRegexCompileFlags.OPTIMIZE | regex.caseless ? GRegexCompileFlags.CASELESS : cast(GRegexCompileFlags) 0; - flags = flags | GRegexCompileFlags.MULTILINE; + GRegexCompileFlags flags = GRegexCompileFlags.Optimize | regex.caseless ? GRegexCompileFlags.Caseless : cast(GRegexCompileFlags) 0; + flags = flags | GRegexCompileFlags.Multiline; return new GRegex(regex.pattern, flags, cast(GRegexMatchFlags) 0); } @@ -225,7 +225,7 @@ VRegex compileVRegex(TerminalRegex regex) { if (regex.caseless) { flags |= PCRE2Flags.CASELESS; } - return VRegex.newMatch(regex.pattern, -1, flags); + return VRegex.newForMatch(regex.pattern, -1, flags); } shared static this() { @@ -519,7 +519,7 @@ private: } void assertMatchAnchored(string pattern, string search, string expected) { - string value = getMatch(pattern, search, GRegexCompileFlags.ANCHORED, cast(GRegexMatchFlags)0); + string value = getMatch(pattern, search, GRegexCompileFlags.Anchored, cast(GRegexMatchFlags)0); if (expected == ENTIRE) { assert(value == search); } else { diff --git a/source/gx/tilix/terminal/search.d b/source/gx/tilix/terminal/search.d index 132263157..a048ad4e8 100644 --- a/source/gx/tilix/terminal/search.d +++ b/source/gx/tilix/terminal/search.d @@ -7,34 +7,39 @@ module gx.tilix.terminal.search; import std.experimental.logger; import std.format; -import gdk.Event; -import gdk.Keysyms; - -import gio.ActionGroupIF; -import gio.Menu; -import gio.Settings : GSettings = Settings; -import gio.SimpleAction; -import gio.SimpleActionGroup; - -import glib.GException; -import glib.Regex: GRegex = Regex; -import glib.Variant : GVariant = Variant; - -import gtk.Box; -import gtk.Button; -import gtk.CheckButton; -import gtk.Frame; -import gtk.Image; -import gtk.MenuButton; -import gtk.Popover; -import gtk.Revealer; -import gtk.SearchEntry; -import gtk.ToggleButton; -import gtk.Widget; -import gtk.Version; - -import vte.Regex: VRegex = Regex; -import vte.Terminal : VTE = Terminal; +import gdk.event : Event; +import gdk.event_key : EventKey; +import gdk.event_focus : EventFocus; +import gdk.c.types : GdkModifierType; +// GID does not provide gdk.keysyms, define required constants locally +private enum GdkKeysyms { GDK_Return = 0xff0d, GDK_Escape = 0xff1b } + +import gio.action_group : ActionGroup; +import gio.menu : GMenu = Menu; +import gio.settings : GSettings = Settings; +import gio.simple_action : SimpleAction; +import gio.simple_action_group : SimpleActionGroup; + +import glib.error : ErrorWrap; +import glib.regex: GRegex = Regex; +import glib.variant : GVariant = Variant; + +import gtk.box : Box; +import gtk.button : Button; +import gtk.check_button : CheckButton; +import gtk.frame : Frame; +import gtk.image : Image; +import gtk.menu_button : MenuButton; +import gtk.popover : Popover; +import gtk.revealer : Revealer; +import gtk.search_entry : SearchEntry; +import gtk.toggle_button : ToggleButton; +import gtk.widget : Widget; +import gtk.global : checkVersion; +import gtk.types : Align, IconSize, Orientation, ReliefStyle, ShadowType; + +import vte.regex: VRegex = Regex; +import vte.terminal : VTE = Terminal; import gx.gtk.actions; import gx.gtk.vte; @@ -61,7 +66,7 @@ private: GSettings gsSettings; VTE vte; - ActionGroupIF terminalActions; + ActionGroup terminalActions; SimpleActionGroup sagSearch; SearchEntry seSearch; @@ -79,46 +84,44 @@ private: setHexpand(true); setVexpand(false); - setHalign(GtkAlign.FILL); - setValign(GtkAlign.START); + setHalign(Align.Fill); + setValign(Align.Start); - Box bSearch = new Box(Orientation.HORIZONTAL, 6); - bSearch.setHalign(GtkAlign.CENTER); + Box bSearch = new Box(Orientation.Horizontal, 6); + bSearch.setHalign(Align.Center); bSearch.setMarginLeft(4); bSearch.setMarginRight(4); bSearch.setMarginTop(4); bSearch.setMarginBottom(4); bSearch.setHexpand(true); - Box bEntry = new Box(Orientation.HORIZONTAL, 0); + Box bEntry = new Box(Orientation.Horizontal, 0); bEntry.getStyleContext().addClass("linked"); seSearch = new SearchEntry(); seSearch.setWidthChars(1); seSearch.setMaxWidthChars(30); - if (Version.checkVersion(3, 20, 0).length != 0) { + if (checkVersion(3, 20, 0).length != 0) { seSearch.getStyleContext().addClass("tilix-search-entry"); } - seSearch.addOnSearchChanged(delegate(SearchEntry) { + seSearch.connectSearchChanged(delegate() { setTerminalSearchCriteria(); }); - seSearch.addOnKeyRelease(delegate(Event event, Widget) { - uint keyval; - if (event.getKeyval(keyval)) { - switch (keyval) { - case GdkKeysyms.GDK_Escape: - setRevealChild(false); - vte.grabFocus(); - break; - case GdkKeysyms.GDK_Return: - if (event.key.state & GdkModifierType.SHIFT_MASK) { - terminalActions.activateAction(ACTION_FIND_NEXT, null); - } else { - terminalActions.activateAction(ACTION_FIND_PREVIOUS, null); - } - break; - default: - } + seSearch.connectKeyReleaseEvent(delegate(EventKey event) { + uint keyval = event.keyval; + switch (keyval) { + case GdkKeysyms.GDK_Escape: + setRevealChild(false); + vte.grabFocus(); + break; + case GdkKeysyms.GDK_Return: + if (event.state & GdkModifierType.ShiftMask) { + terminalActions.activateAction(ACTION_FIND_NEXT, null); + } else { + terminalActions.activateAction(ACTION_FIND_PREVIOUS, null); + } + break; + default: } return false; }); @@ -127,42 +130,42 @@ private: mbOptions = new MenuButton(); mbOptions.setTooltipText(_("Search Options")); mbOptions.setFocusOnClick(false); - Image iHamburger = new Image("pan-down-symbolic", IconSize.MENU); + Image iHamburger = Image.newFromIconName("pan-down-symbolic", IconSize.Menu); mbOptions.add(iHamburger); mbOptions.setPopover(createPopover); bEntry.add(mbOptions); bSearch.add(bEntry); - Box bButtons = new Box(Orientation.HORIZONTAL, 0); + Box bButtons = new Box(Orientation.Horizontal, 0); bButtons.getStyleContext().addClass("linked"); - Button btnNext = new Button("go-up-symbolic", IconSize.MENU); - btnNext.setTooltipText(_("Find next")); - btnNext.setActionName(getActionDetailedName(ACTION_PREFIX, ACTION_FIND_PREVIOUS)); - btnNext.setCanFocus(false); - bButtons.add(btnNext); + Button btnUp = Button.newFromIconName("go-up-symbolic", IconSize.Menu); + btnUp.setTooltipText(_("Find next")); + btnUp.setActionName(getActionDetailedName(ACTION_PREFIX, ACTION_FIND_PREVIOUS)); + btnUp.setCanFocus(false); + bButtons.add(btnUp); - Button btnPrevious = new Button("go-down-symbolic", IconSize.MENU); - btnPrevious.setTooltipText(_("Find previous")); - btnPrevious.setActionName(getActionDetailedName(ACTION_PREFIX, ACTION_FIND_NEXT)); - btnPrevious.setCanFocus(false); - bButtons.add(btnPrevious); + Button btnDown = Button.newFromIconName("go-down-symbolic", IconSize.Menu); + btnDown.setTooltipText(_("Find previous")); + btnDown.setActionName(getActionDetailedName(ACTION_PREFIX, ACTION_FIND_NEXT)); + btnDown.setCanFocus(false); + bButtons.add(btnDown); bSearch.add(bButtons); - Button btnClose = new Button("window-close-symbolic", IconSize.MENU); - btnClose.setTooltipText(_("Close search box")); - btnClose.setRelief(ReliefStyle.NONE); - btnClose.setFocusOnClick(true); - btnClose.addOnClicked(delegate(Button) { - setRevealChild(false); - vte.grabFocus(); + Button btnClose = Button.newFromIconName("window-close-symbolic", IconSize.Menu); + btnClose.setRelief(ReliefStyle.None); + btnClose.setFocusOnClick(false); + btnClose.connectClicked(delegate() { + this.setRevealChild(false); + this.vte.grabFocus(); }); bSearch.packEnd(btnClose, false, false, 0); - Frame frame = new Frame(bSearch, null); - frame.setShadowType(ShadowType.NONE); + Frame frame = new Frame(null); + frame.add(bSearch); + frame.setShadowType(ShadowType.None); frame.getStyleContext().addClass("tilix-search-frame"); add(frame); } @@ -201,13 +204,13 @@ private: } Popover createPopover() { - Menu model = new Menu(); + GMenu model = new GMenu(); model.append(_("Match case"), getActionDetailedName(ACTION_SEARCH_PREFIX, ACTION_SEARCH_MATCH_CASE)); model.append(_("Match entire word only"), getActionDetailedName(ACTION_SEARCH_PREFIX, ACTION_SEARCH_ENTIRE_WORD_ONLY)); model.append(_("Wrap around"), getActionDetailedName(ACTION_SEARCH_PREFIX, ACTION_SEARCH_WRAP_AROUND)); model.append(_("Match as regular expression"), getActionDetailedName(ACTION_SEARCH_PREFIX, ACTION_SEARCH_MATCH_REGEX)); - return new Popover(mbOptions, model); + return Popover.newFromModel(mbOptions, model); } void updateActionsState() @@ -237,9 +240,9 @@ private: flags |= PCRE2Flags.CASELESS; } trace("Setting VTE.Regex for pattern %s", text); - vte.searchSetRegex(VRegex.newSearch(text, -1, flags), 0); + vte.searchSetRegex(VRegex.newForSearch(text, -1, flags), 0); seSearch.getStyleContext().removeClass("error"); - } catch (GException ge) { + } catch (ErrorWrap ge) { string message = format(_("Search '%s' is not a valid regex\n%s"), text, ge.msg); seSearch.getStyleContext().addClass("error"); error(message); @@ -249,7 +252,7 @@ private: public: - this(VTE vte, ActionGroupIF terminalActions) { + this(VTE vte, ActionGroup terminalActions) { super(); this.vte = vte; @@ -257,21 +260,21 @@ public: gsSettings = new GSettings(SETTINGS_ID); createUI(); - gsSettings.addOnChanged(delegate(string key, GSettings) { + gsSettings.connectChanged(null, delegate(string key) { if (key == SETTINGS_ALWAYS_USE_REGEX_IN_SEARCH) updateActionsState(); }); - this.addOnDestroy(delegate(Widget) { + connectDestroy(delegate() { this.vte = null; this.terminalActions = null; }); - seSearch.addOnFocusIn(delegate(Event event, Widget widget) { - onSearchEntryFocusIn.emit(widget); + seSearch.connectFocusInEvent(delegate(EventFocus event) { + onSearchEntryFocusIn.emit(this); return false; }); - seSearch.addOnFocusIn(delegate(Event event, Widget widget) { - onSearchEntryFocusOut.emit(widget); + seSearch.connectFocusOutEvent(delegate(EventFocus event) { + onSearchEntryFocusOut.emit(this); return false; }); } diff --git a/source/gx/tilix/terminal/terminal.d b/source/gx/tilix/terminal/terminal.d index 8f8db71ed..90d676c31 100644 --- a/source/gx/tilix/terminal/terminal.d +++ b/source/gx/tilix/terminal/terminal.d @@ -31,93 +31,131 @@ import std.traits; import std.typecons; import std.uuid; -import cairo.Context; - -import gdk.Atom; -import gdk.DragContext; -import gdk.Event; -import gdk.Keysyms; -import gdk.RGBA; -import gdk.Screen; -import gdk.Window: GdkWindow = Window; - -import gdkpixbuf.Pixbuf; - -import gio.ActionMapIF; -import gio.FileIF : GFileIF = FileIF; -import gio.FileT: GFileT = FileT; -import gio.Menu : GMenu = Menu; -import gio.MenuItem : GMenuItem = MenuItem; -import gio.Notification : GNotification = Notification; -import gio.Settings : GSettings = Settings; -import gio.SimpleAction; -import gio.SimpleActionGroup; -import gio.ThemedIcon; - -import glib.ArrayG; -import glib.GException; -import glib.MatchInfo : GMatchInfo = MatchInfo; -import glib.Regex : GRegex = Regex; -import glib.ShellUtils; -import glib.SimpleXML; -import glib.Str; -import glib.Util; -import glib.URI; -import glib.Variant : GVariant = Variant; -import glib.VariantBuilder : GVariantBuilder = VariantBuilder; -import glib.VariantType : GVariantType = VariantType; - -import gobject.ObjectG; -import gobject.Signals; - -import gtk.Adjustment; -import gtk.Box; -import gtk.Button; -import gtk.Clipboard; -import gtk.CssProvider; -import gtk.Dialog; -import gtk.DragAndDrop; -import gtk.Entry; -import gtk.EventBox; -import gtk.FileChooserDialog; -import gtk.FileFilter; -import gtk.Frame; -import gtk.Image; -import gtk.InfoBar; -import gtk.Label; -import gtk.Main; -import gtk.Menu; -import gtk.MenuButton; -import gtk.MenuItem; -import gtk.MessageDialog; -import gtk.MountOperation; -import gtk.Overlay; -import gtk.Popover; -import gtk.Revealer; -import gtk.ScrolledWindow; -import gtk.Scrollbar; -import gtk.SelectionData; -import gtk.Separator; -import gtk.SeparatorMenuItem; -import gtk.Spinner; -import gtk.StyleContext; -import gtk.TargetEntry; -import gtk.ToggleButton; -import gtk.Version; -import gtk.Widget; -import gtk.Window; - -import gtkc.glib; - -import pango.PgCairo; -import pango.PgContext; -import pango.PgFontDescription; -import pango.PgLayout; - -import vte.Pty; -import vte.Regex : VRegex = Regex; -import vte.Terminal : VTE = Terminal; -import vtec.vtetypes; +// GID imports - cairo +import cairo.context : Context; +import cairo.c.types : cairo_operator_t; + +// GID imports - gdk +import gdk.c.types : GdkAtom, GdkAtom_st; +import gdk.atom : Atom; + +import gdk.drag_context : DragContext; +import gdk.event : Event; +import gdk.event_button : EventButton; +import gdk.event_focus : EventFocus; +import gdk.event_key : EventKey; +import gdk.event_crossing : EventCrossing; +import gdk.rgba : RGBA; +import gdk.screen : Screen; +import gdk.window : GdkWindow = Window; +import gdk.types : EventType, ModifierType, DragAction, ScrollDirection; +import gdk.c.types : GdkDragAction, GdkEventScroll, GdkModifierType, GdkRectangle, GdkPoint; + +// GID imports - gdkpixbuf +import gdkpixbuf.pixbuf : Pixbuf; + +// GID imports - gio +import gio.action_map : ActionMap; +import gio.dbus_connection : DBusConnection; +import gio.file : File, GFileIF = File; +import gio.menu : GMenu = Menu; +import gio.menu_item : GMenuItem = MenuItem; +import gio.mount_operation : MountOperation; +import gio.notification : GNotification = Notification; +import gio.output_stream : OutputStream; +import gio.settings : GSettings = Settings; +import gio.simple_action : SimpleAction; +import gio.simple_action_group : SimpleActionGroup; +import gio.themed_icon : ThemedIcon; +import gio.unix_fdlist : UnixFDList; +import gio.c.types : GDBusCallFlags, GDBusConnection, GDBusConnectionFlags, GDBusSignalCallback, GDBusSignalFlags, GFileCreateFlags; + +// GID imports - glib +import glib.error : ErrorWrap; +import glib.global : getCurrentDir, getHomeDir, markupEscapeText, shellQuote, shellParseArgv, filenameToUri, filenameFromUri; +import glib.main_context : MainContext; +import glib.match_info : GMatchInfo = MatchInfo; +import glib.regex : GRegex = Regex; +import glib.uri : Uri; +import glib.variant : GVariant = Variant; +import glib.variant_builder : GVariantBuilder = VariantBuilder; +import glib.variant_type : GVariantType = VariantType; +import glib.c.functions : g_source_remove, g_variant_get, g_variant_new, g_variant_new_handle; +import glib.c.types : GRegexMatchFlags, GSpawnFlags, GPid, gulong, glong; +import gobject.c.types : GCallback, GClosure, GClosureNotify, GConnectFlags; + +// GID imports - gobject +import gobject.object : ObjectWrap; +import gobject.global : signalHandlerDisconnect; +import gobject.c.types : GConnectFlags; + +// GID imports - gtk +import gtk.adjustment : Adjustment; +import gtk.box : Box; +import gtk.button : Button; +import gtk.clipboard : Clipboard; +import gtk.css_provider : CssProvider; +import gtk.dialog : Dialog; +import gtk.entry : Entry; +import gtk.event_box : EventBox; +import gtk.file_chooser_dialog : FileChooserDialog; +import gtk.file_filter : FileFilter; +import gtk.frame : Frame; +import gtk.global : checkVersion, dragGetSourceWidget, dragSetIconPixbuf, dragSetIconWidget, eventsPending, mainIterationDo, getCurrentEventTime, showUri, showUriOnWindow; +import gtk.image : Image; +import gtk.info_bar : InfoBar; +import gtk.label : Label; +import gtk.menu : Menu; +import gtk.menu_button : MenuButton; +import gtk.menu_item : MenuItem; +import gtk.message_dialog : MessageDialog; +import gtk.overlay : Overlay; +import gtk.popover : Popover; +import gtk.revealer : Revealer; +import gtk.scrollbar : Scrollbar; +import gtk.scrolled_window : ScrolledWindow; +import gtk.selection_data : SelectionData; +import gtk.separator : Separator; +import gtk.separator_menu_item : SeparatorMenuItem; +import gtk.spinner : Spinner; +import gtk.style_context : StyleContext; +import gtk.target_entry : TargetEntry; +import gtk.target_list : TargetList; +import gtk.toggle_button : ToggleButton; +import gtk.widget : Widget; +import gtk.window : Window; +import gtk.types : DestDefaults, DialogFlags, FileChooserAction, Align, IconSize, MessageType, Orientation, PolicyType, PositionType, ReliefStyle, ResponseType, ShadowType, StateFlags, TargetFlags, ButtonsType; +import gtk.c.types : GtkDragResult, GtkWindowType, GtkStateFlags, GtkPolicyType; +import gtk.container : Container; +import pango.types : EllipsizeMode; +import gtk.c.functions : gtk_message_dialog_new; +import gtk.c.types : GtkMessageType, GtkButtonsType, GtkWidget, GtkWindow; + +// GID imports - pango +import pango.font_description : PgFontDescription = FontDescription; +import pango.layout : PgLayout = Layout; + +// GID imports - vte +import vte.pty : Pty; +import vte.regex : VRegex = Regex; +import vte.terminal : VTE = Terminal; +import vte.types : Format, CursorBlinkMode, CursorShape, EraseBinding, TextBlinkMode, PtyFlags, WriteFlags; +import pango.types : WrapMode, Alignment, SCALE; +import pangocairo.global : PgCairo = createLayout, showLayout; +import vte.c.types : VteTerminal, GdkRGBA, VteCursorBlinkMode, VteCursorShape, VteEraseBinding, VtePtyFlags, VteTextBlinkMode; + +import gid.gid : No, Yes; + +import glib.c.functions : g_timeout_add; +import glib.c.types : GSourceFunc; + +import gdk.cursor : Cursor; +import gdk.types : CursorType; +import gdk.rectangle : Rectangle; +import cairo.types : Operator; +import gdk.event_scroll : EventScroll; + +import gobject.global : signalHandlerBlock, signalHandlerUnblock; import gx.gtk.actions; import gx.gtk.cairo; @@ -126,7 +164,9 @@ import gx.gtk.clipboard; import gx.gtk.dialog; import gx.gtk.resource; import gx.gtk.util; +import gx.gtk.util : getSettingsStrv; import gx.gtk.vte; +import gx.gtk.threads; import gx.i18n.l10n; import gx.util.array; @@ -151,6 +191,25 @@ import gx.tilix.terminal.util; import gx.tilix.terminal.monitor; import gx.tilix.terminal.activeprocess; +// GID does not provide gdk.keysyms, so define the required key constants locally +private enum GdkKeysyms { + GDK_Return = 0xff0d, + GDK_c = 0x063, + GDK_Escape = 0xff1b, +} + +// Define GDK selection atoms - these are obtained at runtime +private __gshared Atom GDK_SELECTION_CLIPBOARD; +private __gshared Atom GDK_SELECTION_PRIMARY; + +shared static this() { + GDK_SELECTION_CLIPBOARD = Atom.intern("CLIPBOARD", false); + GDK_SELECTION_PRIMARY = Atom.intern("PRIMARY", false); +} + +// Define missing constants +private enum GDK_CURRENT_TIME = 0; + /** * When dragging over VTE, specifies which quandrant new terminal * should snap to @@ -322,7 +381,7 @@ private: sagTerminalActions = new SimpleActionGroup(); createActions(sagTerminalActions); - Box box = new Box(Orientation.VERTICAL, 0); + Box box = new Box(Orientation.Vertical, 0); add(box); // Create the title bar of the pane Widget titlePane = createTitlePane(); @@ -339,7 +398,7 @@ private: * Creates the top bar of the terminal pane */ Widget createTitlePane() { - bTitle = new Box(Orientation.HORIZONTAL, 0); + bTitle = new Box(Orientation.Horizontal, 0); bTitle.getStyleContext().addClass("terminal-titlebar"); //Showing is controlled by terminal title preference bTitle.setNoShowAll(true); @@ -347,7 +406,7 @@ private: lblTitle = new Label(_("Terminal")); lblTitle.getStyleContext().addClass("tilix-terminal-title"); - lblTitle.setEllipsize(PangoEllipsizeMode.START); + lblTitle.setEllipsize(EllipsizeMode.Start); lblTitle.setUseMarkup(true); //Profile Menu @@ -356,40 +415,40 @@ private: //Encoding Menu encodingMenu = new GMenu(); - Box bTitleLabel = new Box(Orientation.HORIZONTAL, 6); + Box bTitleLabel = new Box(Orientation.Horizontal, 6); bTitleLabel.add(lblTitle); - bTitleLabel.add(new Image("pan-down-symbolic", IconSize.MENU)); + bTitleLabel.add(Image.newFromIconName("pan-down-symbolic", IconSize.Menu)); mbTitle = new MenuButton(); - mbTitle.setRelief(ReliefStyle.NONE); + mbTitle.setRelief(ReliefStyle.None); mbTitle.setFocusOnClick(false); mbTitle.setPopover(createPopover(mbTitle)); - mbTitle.addOnButtonPress(delegate(Event e, Widget w) { + mbTitle.connectButtonPressEvent(delegate(EventButton e) { buildProfileMenu(); buildEncodingMenu(); return false; }); mbTitle.add(bTitleLabel); - mbTitle.addOnShow(delegate(Widget) { + mbTitle.connectShow(delegate(Widget w) { mbTitle.queueResize(); - }, ConnectFlags.AFTER); + }, Yes.After); mbTitle.setMarginRight(10); bTitle.packStart(mbTitle, false, false, 0); //Close Button - Button btnClose = new Button("window-close-symbolic", IconSize.MENU); + Button btnClose = Button.newFromIconName("window-close-symbolic", IconSize.Menu); btnClose.setTooltipText(_("Close")); - btnClose.setRelief(ReliefStyle.NONE); + btnClose.setRelief(ReliefStyle.None); btnClose.setFocusOnClick(false); btnClose.setActionName(getActionDetailedName(ACTION_PREFIX, ACTION_CLOSE)); bTitle.packEnd(btnClose, false, false, 0); //Maximize Button - btnMaximize = new Button("window-maximize-symbolic", IconSize.MENU); + btnMaximize = Button.newFromIconName("window-maximize-symbolic", IconSize.Menu); btnMaximize.setTooltipText(_("Maximize")); - btnMaximize.setRelief(ReliefStyle.NONE); + btnMaximize.setRelief(ReliefStyle.None); btnMaximize.setFocusOnClick(false); btnMaximize.setActionName(getActionDetailedName(ACTION_PREFIX, ACTION_MAXIMIZE)); bTitle.packEnd(btnMaximize, false, false, 0); @@ -397,21 +456,21 @@ private: //Synchronize Input Button tbSyncInput = new ToggleButton(); tbSyncInput.setNoShowAll(true); - tbSyncInput.setImage(new Image("input-keyboard-symbolic", IconSize.MENU)); + tbSyncInput.setImage(Image.newFromIconName("input-keyboard-symbolic", IconSize.Menu)); tbSyncInput.setTooltipText(_("Disable input synchronization for this terminal")); - tbSyncInput.setRelief(ReliefStyle.NONE); + tbSyncInput.setRelief(ReliefStyle.None); tbSyncInput.setFocusOnClick(false); tbSyncInput.setActionName(getActionDetailedName(ACTION_PREFIX, ACTION_SYNC_INPUT_OVERRIDE)); bTitle.packEnd(tbSyncInput, false, false, 0); //Read Only Image - imgReadOnly = new Image("changes-prevent-symbolic", IconSize.MENU); + imgReadOnly = Image.newFromIconName("changes-prevent-symbolic", IconSize.Menu); imgReadOnly.setNoShowAll(true); imgReadOnly.setTooltipText(_("Read-Only")); bTitle.packEnd(imgReadOnly, false, false, 0); //New Output - imgNewOuput = new Image("insert-text-symbolic", IconSize.MENU); + imgNewOuput = Image.newFromIconName("insert-text-symbolic", IconSize.Menu); imgNewOuput.setNoShowAll(true); imgNewOuput.setTooltipText(_("New output")); bTitle.packEnd(imgNewOuput, false, false, 0); @@ -426,18 +485,18 @@ private: EventBox evtTitle = new EventBox(); evtTitle.add(bTitle); //Handle double click for window state change - evtTitle.addOnButtonPress(delegate(Event event, Widget) { + evtTitle.connectButtonPressEvent(delegate(EventButton event) { int childX, childY; mbTitle.translateCoordinates(evtTitle, 0, 0, childX, childY); //Ignore clicks propagated from Menu Button, see #215 - if (event.button.x >= childX && event.button.x <= childX + mbTitle.getAllocatedWidth() && event.button.y >= childY - && event.button.y <= childY + mbTitle.getAllocatedHeight()) { + if (event.x >= childX && event.x <= childX + mbTitle.getAllocatedWidth() && event.y >= childY + && event.y <= childY + mbTitle.getAllocatedHeight()) { return false; } - if (event.getEventType() == EventType.DOUBLE_BUTTON_PRESS && event.button.button == MouseButton.PRIMARY) { + if (event.type == EventType.DoubleButtonPress && event.button == MouseButton.Primary) { toggleMaximize(); - } else if (event.getEventType() == EventType.BUTTON_PRESS) { - if (event.button.button == MouseButton.MIDDLE && gsSettings.getBoolean(SETTINGS_MIDDLE_CLICK_CLOSE_KEY)) { + } else if (event.type == EventType.ButtonPress) { + if (event.button == MouseButton.Middle && gsSettings.getBoolean(SETTINGS_MIDDLE_CLICK_CLOSE_KEY)) { SimpleAction close = cast(SimpleAction) sagTerminalActions.lookupAction(ACTION_CLOSE); close.activate(null); } else { @@ -519,7 +578,7 @@ private: if (checkVTEVersion(VTE_VERSION_COPY_AS_HTML)) { saCopyAsHtml = registerActionWithSettings(group, ACTION_PREFIX, ACTION_COPY_AS_HTML, gsShortcuts, delegate(GVariant, SimpleAction) { if (vte.getHasSelection()) { - vte.copyClipboardFormat(VteFormat.HTML); + vte.copyClipboardFormat(Format.Html); } }); } @@ -621,7 +680,7 @@ private: dialog.title = _overrideTitle.length == 0 ? gsProfile.getString(SETTINGS_PROFILE_TITLE_KEY) : _overrideTitle; dialog.command = _overrideCommand; dialog.showAll(); - if (dialog.run() == ResponseType.OK) { + if (dialog.run() == ResponseType.Ok) { _overrideTitle = dialog.title; _overrideBadge = dialog.badge; _overrideCommand = dialog.command; @@ -660,9 +719,9 @@ private: //Open CWD in Browser registerActionWithSettings(group, ACTION_PREFIX, ACTION_FILE_BROWSER, gsShortcuts, delegate(GVariant state, SimpleAction sa) { // Only support local directories for now - string uri = URI.filenameToUri(gst.currentLocalDirectory, null); + string uri = filenameToUri(gst.currentLocalDirectory, null); tracef("Opening directory: %s, hostname: %s, uri: %s", gst.currentDirectory, gst.currentHostname, uri); - MountOperation.showUri(null, uri, Main.getCurrentEventTime); + showUri(null, uri, cast(uint) getCurrentEventTime()); }); //Clear Terminal && Reset and Clear Terminal @@ -708,16 +767,16 @@ private: //Insert Password registerActionWithSettings(group, ACTION_PREFIX, ACTION_INSERT_PASSWORD, gsShortcuts, delegate(GVariant state, SimpleAction sa) { - import gtkc.Loader: Linker; - import secretc.secret: LIBRARY_SECRET; - if (Linker.isLoaded(LIBRARY_SECRET)) { + import core.sys.posix.dlfcn : dlopen, dlclose, RTLD_NOW; + enum LIBRARY_SECRET = "libsecret-1.so.0"; + void* secretHandle = dlopen(LIBRARY_SECRET.ptr, RTLD_NOW); scope(exit) if (secretHandle) dlclose(secretHandle); if (secretHandle !is null) { tracef("Library %s was loaded", LIBRARY_SECRET); PasswordManagerDialog pdm = new PasswordManagerDialog(cast(Window)this.getToplevel()); scope(exit) {pdm.destroy();} pdm.showAll(); - if (pdm.run() == ResponseType.APPLY) { + if (pdm.run() == ResponseType.Apply) { string password = pdm.password; - vte.feedChild(password); + vte.feedChild(cast(ubyte[]) password); static if (!USE_COMMIT_SYNCHRONIZATION) { if (isSynchronizedInput()) { SyncInputEvent se = SyncInputEvent(_terminalUUID, SyncInputEventType.INSERT_TEXT, null, password); @@ -741,8 +800,7 @@ private: //Select Profile GVariant pu = new GVariant(activeProfileUUID); saProfileSelect = registerAction(group, ACTION_PREFIX, ACTION_PROFILE_SELECT, null, delegate(GVariant value, SimpleAction sa) { - size_t l; - string uuid = value.getString(l); + string uuid = value.getString(); activeProfileUUID = uuid; saProfileSelect.setState(value); }, pu.getType(), pu); @@ -755,9 +813,8 @@ private: // Select Encoding GVariant encoding = new GVariant(gsProfile.getString(SETTINGS_PROFILE_ENCODING_KEY)); saEncodingSelect = registerAction(group, ACTION_PREFIX, ACTION_ENCODING_SELECT, null, delegate(GVariant value, SimpleAction sa) { - size_t l; sa.setState(value); - vte.setEncoding(value.getString(l)); + vte.setEncoding(value.getString()); }, encoding.getType(), encoding); // Add Bookmark @@ -810,10 +867,10 @@ private: Popover pm = new Popover(parent); // Force VTE to redraw on showing/hiding of popover if dimUnfocused is active - pm.addOnMap(delegate(Widget) { + pm.connectMap(delegate(Widget w) { if (dimPercent > 0) vte.queueDraw(); }); - pm.addOnUnmap(delegate(Widget) { + pm.connectUnmap(delegate(Widget w) { if (dimPercent > 0) vte.queueDraw(); }); pm.bindModel(model, null); @@ -904,8 +961,8 @@ private: vte.setAllowHyperlink(true); } //Event handlers - vteHandlers ~= vte.addOnChildExited(&onTerminalChildExited); - vte.addOnBell(delegate(VTE) { + vteHandlers ~= vte.connectChildExited(&onTerminalChildExited); + vte.connectBell(delegate() { // Originally planned on not showing bell when window is not active but too many edge cases // like window is active in different monitor, window is visible but not active, just a message // to deal with IMHO. Notifications right solution for that @@ -917,19 +974,19 @@ private: } }); - vteHandlers ~= vte.addOnWindowTitleChanged(delegate(VTE terminal) { + vteHandlers ~= vte.connectWindowTitleChanged(delegate(VTE terminal) { if (vte !is null) { trace("Window title changed"); gst.updateState(); updateDisplayText(); } }); - vteHandlers ~= vte.addOnIconTitleChanged(delegate(VTE terminal) { + vteHandlers ~= vte.connectIconTitleChanged(delegate(VTE terminal) { if (vte !is null) { updateDisplayText(); } }); - vteHandlers ~= vte.addOnCurrentDirectoryUriChanged(delegate(VTE terminal) { + vteHandlers ~= vte.connectCurrentDirectoryUriChanged(delegate(VTE terminal) { if (vte is null) return; string hostname, directory; @@ -941,15 +998,19 @@ private: checkAutomaticProfileSwitch(); } }); - vteHandlers ~= vte.addOnCurrentFileUriChanged(delegate(VTE terminal) { trace("Current file is " ~ vte.getCurrentFileUri); }); - vteHandlers ~= vte.addOnFocusIn(&onTerminalWidgetFocusIn); - vteHandlers ~= vte.addOnFocusOut(&onTerminalWidgetFocusOut); - vteHandlers ~= vte.addOnNotificationReceived(delegate(string summary, string _body, VTE terminal) { + vteHandlers ~= vte.connectCurrentFileUriChanged(delegate(VTE terminal) { trace("Current file is " ~ vte.getCurrentFileUri); }); + vteHandlers ~= vte.connectFocusInEvent(delegate(EventFocus event) { + return onTerminalWidgetFocusIn(event, vte); + }); + vteHandlers ~= vte.connectFocusOutEvent(delegate(EventFocus event) { + return onTerminalWidgetFocusOut(event, vte); + }); + vteHandlers ~= vte.connectNotificationReceived(delegate(string summary, string _body, VTE terminal) { if (terminalInitialized && !terminal.hasFocus() && gpid > 0) { notifyProcessNotification(summary, _body, uuid); } }); - vteHandlers ~= vte.addOnContentsChanged(delegate(VTE) { + vteHandlers ~= vte.connectContentsChanged(delegate() { if (vte is null) return; // VTE configuration problem, Issue #34 @@ -984,8 +1045,8 @@ private: glong cursorCol, cursorRow; vte.getCursorPosition(cursorCol, cursorRow); if (cursorRow > 0) cursorRow--; - ArrayG attr = new ArrayG(false, false, 16); - string text = vte.getTextRange(cursorRow, 0, cursorRow, 128, null, null, attr); + size_t textLen; + string text = vte.getTextRangeFormat(Format.Text, cursorRow, 0, cursorRow, 128, textLen); notifyProcessNotification(_("Terminal Activity"), text, uuid); } } @@ -1005,65 +1066,64 @@ private: * Monitor changes in the VTE to test for triggers */ if (checkVTEFeature(TerminalFeature.EVENT_SCREEN_CHANGED)) { - vteHandlers ~= vte.addOnContentsChanged(&onVTECheckTriggers, GConnectFlags.AFTER); - vteHandlers ~= vte.addOnTerminalScreenChanged(&onVTEScreenChanged); + vteHandlers ~= vte.connectContentsChanged(delegate() { + onVTECheckTriggers(vte); + }, Yes.After); + vteHandlers ~= vte.connectTerminalScreenChanged(&onVTEScreenChanged); } - vteHandlers ~= vte.addOnSizeAllocate(delegate(GdkRectangle*, Widget) { + vteHandlers ~= vte.connectSizeAllocate(delegate(Rectangle alloc) { updateDisplayText(); - }, GConnectFlags.AFTER); - vteHandlers ~= vte.addOnEnterNotify(delegate(Event event, Widget) { + }, Yes.After); + vteHandlers ~= vte.connectEnterNotifyEvent(delegate(EventCrossing event) { if (vte is null) return false; if (gsSettings.getBoolean(SETTINGS_TERMINAL_FOCUS_FOLLOWS_MOUSE_KEY)) { vte.grabFocus(); } return false; - }, GConnectFlags.AFTER); + }, Yes.After); - vteHandlers ~= vte.addOnButtonPress(&onTerminalButtonPress); - vteHandlers ~= vte.addOnKeyRelease(delegate(Event event, Widget widget) { - if (vte is null) return false; + vteHandlers ~= vte.connectButtonPressEvent(delegate(EventButton event) { + return onTerminalButtonPress(event, vte); + }); + vteHandlers ~= vte.connectKeyPressEvent(delegate(EventKey event) { + if (vte is null || event is null) return false; // If copy is assigned to control-c, check if VTE has selection and then // copy otherwise pass it on to VTE as interrupt - uint keyval; - event.getKeyval(keyval); - if ((keyval == GdkKeysyms.GDK_c) && (event.key.state & ModifierType.CONTROL_MASK)) { + uint keyval = event.keyval; + if ((keyval == GdkKeysyms.GDK_c) && (event.state & GdkModifierType.ControlMask)) { string[] actions = tilix.getActionsForAccel("c"); if (actions.length > 0 && (actions[0] == getActionDetailedName(ACTION_PREFIX,ACTION_COPY) || actions[0] == getActionDetailedName(ACTION_PREFIX,ACTION_COPY_AS_HTML)) && !vte.getHasSelection()) { string controlc = "\u0003"; - vte.feedChild(controlc); + vte.feedChild(cast(ubyte[]) controlc); return true; } } - return false; - }); - vteHandlers ~= vte.addOnKeyPress(delegate(Event event, Widget widget) { - if (vte is null) return false; - if (event.key.keyval == GdkKeysyms.GDK_Return && checkVTEFeature(TerminalFeature.EVENT_SCREEN_CHANGED) && currentScreen == TerminalScreen.NORMAL) { + if (event.keyval == GdkKeysyms.GDK_Return && checkVTEFeature(TerminalFeature.EVENT_SCREEN_CHANGED) && currentScreen == TerminalScreen.NORMAL) { glong row, column; vte.getCursorPosition(column, row); addPromptPosition(row); tracef("Added prompt position %d", row); } - if (isSynchronizedInput() && event.key.sendEvent != SendEvent.SYNC) { + if (isSynchronizedInput() && event.sendEvent != SendEvent.SYNC) { static if (USE_COMMIT_SYNCHRONIZATION) { // Only synchronize hard code VTE keys otherwise let commit event take care of it - if (!isVTEHandledKeystroke(event.key.keyval, event.key.state)) return false; + if (!isVTEHandledKeystroke(event.keyval, cast(GdkModifierType)event.state)) return false; } - tracef("Synchronizing key %d", event.key.keyval); - SyncInputEvent se = SyncInputEvent(_terminalUUID, SyncInputEventType.KEY_PRESS, event); + tracef("Synchronizing key %d", event.keyval); + SyncInputEvent se = SyncInputEvent(_terminalUUID, SyncInputEventType.KEY_PRESS, cast(Event) event); onSyncInput.emit(this, se); } return false; }); - vteHandlers ~= vte.addOnSelectionChanged(delegate(VTE) { + vteHandlers ~= vte.connectSelectionChanged(delegate() { if (vte is null) return; if (vte.getHasSelection() && gsSettings.getBoolean(SETTINGS_COPY_ON_SELECT_KEY)) { @@ -1072,7 +1132,7 @@ private: }); static if (USE_COMMIT_SYNCHRONIZATION) { - _commitHandlerId = vte.addOnCommit(delegate(string text, uint length, VTE) { + _commitHandlerId = vte.connectCommit(delegate(string text, uint length, VTE) { //tracef("%d Terminal Commit: %s", _terminalID, text); if (vte !is null && isSynchronizedInput() && length > 0) { // Workaround for #888 @@ -1087,22 +1147,22 @@ private: // prompt positions if user cleared VTE buffer, i.e. "clear" command. // Used for terminal-next-prompt and terminal-previous-prompt actions if (checkVTEFeature(TerminalFeature.EVENT_SCREEN_CHANGED)) { - vteHandlers ~= vte.addOnTextDeleted(delegate(VTE) { + vteHandlers ~= vte.connectTextDeleted(delegate() { checkPromptBuffer(); }); } pmContext = new Popover(vte); pmContext.setModal(true); - pmContext.setPosition(PositionType.BOTTOM); + pmContext.setPosition(PositionType.Bottom); // Force VTE to redraw on showing/hiding of popover if dimUnfocused is active - pmContext.addOnMap(delegate(Widget) { + pmContext.connectMap(delegate(Widget w) { if (dimPercent > 0) vte.queueDraw(); }); - pmContext.addOnUnmap(delegate(Widget) { + pmContext.connectUnmap(delegate(Widget w) { if (dimPercent > 0) vte.queueDraw(); }); - pmContext.addOnClosed(delegate(Popover) { + pmContext.connectClosed(delegate() { // See #305 for more info on why this is here saCopy.setEnabled(true); if (saCopyAsHtml !is null) { @@ -1111,51 +1171,52 @@ private: saPaste.setEnabled(true); }); - vteHandlers ~= vte.addOnPopupMenu(delegate(Widget) { + vteHandlers ~= vte.connectPopupMenu(delegate() { showContextPopover(); return true; }); if (_useOverlayScrollbar == 2) { - if ( Version.checkVersion(3, GTK_SCROLLEDWINDOW_VERSION, 0).length != 0 || environment.get("GTK_OVERLAY_SCROLLING","1") == "0") _useOverlayScrollbar = 0; + if ( checkVersion(3, GTK_SCROLLEDWINDOW_VERSION, 0).length != 0 || environment.get("GTK_OVERLAY_SCROLLING","1") == "0") _useOverlayScrollbar = 0; else _useOverlayScrollbar = gsSettings.getBoolean(SETTINGS_USE_OVERLAY_SCROLLBAR_KEY)?-1:0; tracef("Initialized overlay scrollbar to %d", _useOverlayScrollbar); } terminalOverlay = new Overlay(); if (useOverlayScrollbar) { - sw = new ScrolledWindow(vte); + sw = new ScrolledWindow(); + sw.add(vte); sw.getStyleContext.addClass("tilix-terminal-scrolledwindow"); sw.setPropagateNaturalHeight(true); sw.setPropagateNaturalWidth(true); - sw.getVadjustment().addOnValueChanged(&updateNewOutputIndicator); + sw.getVadjustment().connectValueChanged(&updateNewOutputIndicator); terminalOverlay.add(sw); } else { terminalOverlay.add(vte); } - Box terminalBox = new Box(Orientation.HORIZONTAL, 0); + Box terminalBox = new Box(Orientation.Horizontal, 0); terminalBox.add(terminalOverlay); // See https://bugzilla.gnome.org/show_bug.cgi?id=760718 for why we use // a Scrollbar instead of a ScrolledWindow. It's pity considering the // overlay scrollbars look awesome with VTE if (!useOverlayScrollbar) { - sb = new Scrollbar(Orientation.VERTICAL, vte.getVadjustment()); + sb = new Scrollbar(Orientation.Vertical, vte.getVadjustment()); sb.getStyleContext().addClass("tilix-terminal-scrollbar"); - sb.getAdjustment().addOnValueChanged(&updateNewOutputIndicator); + sb.getAdjustment().connectValueChanged(&updateNewOutputIndicator); terminalBox.add(sb); //Draw a transparent background to override Window draw //to support transparent terminal scrollbars without //impacting other chrome. If no scrollbar CSSProvider is loaded //then this drawing does not happen - terminalBox.addOnDraw(delegate(Scoped!Context cr, Widget w) { + terminalBox.connectDraw(delegate(Context cr, Widget w) { if (sbProvider !is null) { cr.save(); // Paint Transparent cr.setSourceRgba(0, 0, 0, 0); - cr.setOperator(cairo_operator_t.SOURCE); + cr.setOperator(cairo_operator_t.Source); // Switched to just painting the scrollbar area, that 1 pixel clip that was required was giving // me the twitches @@ -1181,7 +1242,7 @@ private: vte.setDisableBGDraw(true); } - Box box = new Box(Orientation.VERTICAL, 0); + Box box = new Box(Orientation.Vertical, 0); rFind = new SearchRevealer(vte, sagTerminalActions); rFind.onSearchEntryFocusIn.connect(&terminalWidgetFocusIn); rFind.onSearchEntryFocusOut.connect(&terminalWidgetFocusOut); @@ -1348,7 +1409,7 @@ private: icon = "window-maximize-symbolic"; btnMaximize.setTooltipText(_("Maximize")); } - btnMaximize.setImage(new Image(icon, IconSize.BUTTON)); + btnMaximize.setImage(Image.newFromIconName(icon, IconSize.Button)); } /** @@ -1381,15 +1442,18 @@ private: */ void selectBookmark() { BookmarkChooser bc = new BookmarkChooser(cast(Window)getToplevel(), BMSelectionMode.LEAF); - scope(exit) {bc.destroy();} + scope(exit) { + bc.hide(); + bc.destroy(); + } bc.showAll(); - if (bc.run() == ResponseType.OK && bc.bookmark !is null) { + if (bc.run() == ResponseType.Ok && bc.bookmark !is null) { string text = bc.bookmark.terminalCommand; if (gsSettings.getBoolean(SETTINGS_BOOKMARK_INCLUDE_RETURN_KEY)) { trace("Add new line"); text ~= '\n'; } - vte.feedChild(text); + vte.feedChild(cast(ubyte[])text); static if (!USE_COMMIT_SYNCHRONIZATION) { if (isSynchronizedInput()) { SyncInputEvent se = SyncInputEvent(_terminalUUID, SyncInputEventType.INSERT_TEXT, null, text); @@ -1419,7 +1483,7 @@ private: BookmarkEditor be = new BookmarkEditor(cast(Window)getToplevel(), BookmarkEditorMode.ADD, bm, true); scope(exit) {be.destroy();} be.showAll(); - if (be.run() == ResponseType.OK) { + if (be.run() == ResponseType.Ok) { FolderBookmark fb = be.folder; bm = be.create(); bmMgr.add(fb, bm); @@ -1434,7 +1498,7 @@ private: return (text.indexOf("sudo") > -1) && (text.indexOf("\n") > -1); } - void advancedPaste(GdkAtom source) { + void advancedPaste(Atom source) { string pasteText = Clipboard.get(source).waitForText(); if (pasteText.length == 0) return; if (pasteText.indexOf("\n") < 0) return paste(source); @@ -1445,9 +1509,9 @@ private: dialog.destroy(); } dialog.showAll(); - if (dialog.run() == ResponseType.APPLY) { + if (dialog.run() == ResponseType.Apply) { pasteText = dialog.text; - vte.pasteText(pasteText[0 .. $]); + vte.feedChild(cast(ubyte[])pasteText); if (gsProfile.getBoolean(SETTINGS_PROFILE_SCROLL_ON_INPUT_KEY)) { scrollToBottom(); } @@ -1461,7 +1525,7 @@ private: focusTerminal(); } - void paste(GdkAtom source) { + void paste(Atom source) { string pasteText = Clipboard.get(source).waitForText(); @@ -1635,10 +1699,10 @@ private: startCol = 0; } //tracef("Testing trigger: (%d, %d) to (%d, %d)", startRow, startCol, cursorRow, cursorCol); - ArrayG attr; //tracef("Checking from %d,%d to %d,%d",startRow, startCol, cursorRow, cursorCol); if (startRow <0) startRow = 0; - string text = vte.getTextRange(startRow, startCol, cursorRow, cursorCol, null, null, attr); + size_t textLen; + string text = vte.getTextRangeFormat(Format.Text, startRow, startCol, cursorRow, cursorCol, textLen); // Update position early in case we get re-entrant event triggerLastRowChecked = cursorRow; triggerLastColChecked = cursorCol; @@ -1730,7 +1794,7 @@ private: break; case TriggerAction.SEND_TEXT: string value = replaceMatchTokens(trigger.parameters, groups); - vte.feedChild(value); + vte.feedChild(cast(ubyte[]) value); break; case TriggerAction.INSERT_PASSWORD: trace("Processing insert password trigger"); @@ -1742,7 +1806,7 @@ private: case TriggerAction.RUN_PROCESS: string process = replaceMatchTokens(trigger.parameters, groups); auto response = executeShell(process); - vte.feedChild(response.output); + vte.feedChild(cast(ubyte[]) response.output); break; } } @@ -1750,15 +1814,15 @@ private: private: // Note this event is binded dynamically so no need to check control wheel preference here - bool onTerminalScroll(GdkEventScroll* event, Widget widget) { - if (vte !is null && (event.state & ModifierType.CONTROL_MASK) && !(event.state & ModifierType.SHIFT_MASK) && !(event.state & ModifierType.MOD1_MASK)) { + bool onTerminalScroll(EventScroll event) { + if (vte !is null && (event.state & GdkModifierType.ControlMask) && !(event.state & GdkModifierType.ShiftMask) && !(event.state & GdkModifierType.Mod1Mask)) { ScrollDirection zoomDirection = event.direction; - if (zoomDirection == ScrollDirection.SMOOTH) { - zoomDirection = (event.deltaY <= 0)?ScrollDirection.UP: ScrollDirection.DOWN; + if (zoomDirection == ScrollDirection.Smooth) { + zoomDirection = (event.deltaY <= 0) ? ScrollDirection.Up : ScrollDirection.Down; } - if (zoomDirection == ScrollDirection.UP) { + if (zoomDirection == ScrollDirection.Up) { zoomIn(); - } else if (zoomDirection == ScrollDirection.DOWN) { + } else if (zoomDirection == ScrollDirection.Down) { zoomOut(); } return true; @@ -1786,8 +1850,8 @@ private: return; case SETTINGS_PROFILE_EXIT_ACTION_HOLD_VALUE: TerminalInfoBar ibRelaunch = new TerminalInfoBar(); - ibRelaunch.addOnResponse(delegate(int response, InfoBar ib) { - if (response == ResponseType.OK) { + ibRelaunch.connectResponse(delegate(int response, InfoBar ib) { + if (response == ResponseType.Ok) { ibRelaunch.destroy(); tracef("Re-launching with %s", _overrideCommand); spawnTerminalProcess(gst.initialCWD, _overrideCommand); @@ -1917,16 +1981,18 @@ private: /** * Signal received when mouse button is pressed in terminal */ - bool onTerminalButtonPress(Event event, Widget widget) { + bool onTerminalButtonPress(EventButton event, Widget widget) { // Find the matching regex that was clicked - void updateMatch(Event event) { + void updateMatch(EventButton btnEvent) { match.clear; int tag = -1; - checkHyperlinkMatch(event); + // Create an Event wrapper from the EventButton's C pointer for APIs that need Event + auto genericEvent = new Event(btnEvent._cPtr(), No.Take); + checkHyperlinkMatch(genericEvent); // Check standard hyperlink if new hyperlink feature returns nothing if (match.match.length == 0) { - match.match = vte.matchCheckEvent(event, tag); + match.match = vte.matchCheckEvent(genericEvent, tag); tracef("Match event received %s", match.match); } if (match.match.length > 0) { @@ -1940,33 +2006,35 @@ private: } } - if (vte is null) return false; + if (vte is null || event is null) return false; - if (event.type == EventType.BUTTON_PRESS) { + // Access button properties directly on EventButton + uint buttonNum = event.button; + ModifierType state = event.state; + if (event.type == EventType.ButtonPress) { updateMatch(event); - switch (event.button.button) { - case MouseButton.PRIMARY: - if ((event.button.state & GdkModifierType.CONTROL_MASK) && match.match) { + switch (buttonNum) { + case MouseButton.Primary: + if ((state & ModifierType.ControlMask) && match.match) { trace("Opening match"); openURI(match); return true; - } else if (event.button.state & GdkModifierType.MOD1_MASK) { - import gtk.TargetList; - TargetList list = new TargetList([new TargetEntry(VTE_DND, TargetFlags.SAME_APP, DropTargets.VTE)]); - dragBegin(list, GdkDragAction.MOVE, MouseButton.PRIMARY, event); + } else if (state & ModifierType.Mod1Mask) { + TargetList list = new TargetList([new TargetEntry(VTE_DND, TargetFlags.SameApp, DropTargets.VTE)]); + auto genericEvent = new Event(event._cPtr(), No.Take); + dragBegin(list, GdkDragAction.Move, MouseButton.Primary, genericEvent); return true; } else { return false; } - case MouseButton.SECONDARY: + case MouseButton.Secondary: trace("Enabling actions"); - if (!(event.button.state & (GdkModifierType.SHIFT_MASK | GdkModifierType.CONTROL_MASK | GdkModifierType.MOD1_MASK)) && vte.onButtonPressEvent(event.button)) - return true; - + // Note: buttonPressEvent is not available in GID VTE bindings + // Just show the context popover widget.grabFocus(); showContextPopover(event); return true; - case MouseButton.MIDDLE: + case MouseButton.Middle: widget.grabFocus(); if (gsSettings.getBoolean(SETTINGS_PASTE_ADVANCED_DEFAULT_KEY)) { advancedPaste(GDK_SELECTION_PRIMARY); @@ -1981,7 +2049,7 @@ private: return false; } - void showContextPopover(Event event = null) { + void showContextPopover(EventButton event = null) { buildContextMenu(); saCopy.setEnabled(vte.getHasSelection()); if (saCopyAsHtml !is null) { @@ -1989,8 +2057,8 @@ private: } saPaste.setEnabled(Clipboard.get(null).waitIsTextAvailable()); if (event !is null) { - GdkRectangle rect = GdkRectangle(to!int(event.button.x), to!int(event.button.y), 1, 1); - pmContext.setPointingTo(&rect); + auto rect = new Rectangle(to!int(event.x), to!int(event.y), 1, 1); + pmContext.setPointingTo(rect); } pmContext.showAll(); } @@ -2013,7 +2081,7 @@ private: string filename, hostname; try { - filename = URI.filenameFromUri(uri, hostname); + filename = filenameFromUri(uri, hostname); } catch (Exception e) { string message = format(_("Could not check file '%s' due to error '%s'"), match.match, e.msg); warning(message); @@ -2055,7 +2123,7 @@ private: spawnShell(command, env, Config.none, currentLocalDirectory); } } - } catch (GException ge) { + } catch (ErrorWrap ge) { string message = format(_("Custom link regex '%s' has an error, ignoring"), tr.pattern); showErrorDialog(cast(Window)getToplevel(), message, _("Regular Expression Error")); error(message); @@ -2068,7 +2136,7 @@ private: } try { tracef("Showing URI %s", uri); - MountOperation.showUri(null, uri, Main.getCurrentEventTime()); + showUriOnWindow(cast(Window)getToplevel(), uri, getCurrentEventTime()); } catch (Exception e) { string message = format(_("Could not open match '%s'"), match.match); showErrorDialog(cast(Window)getToplevel(), message, _("Error Opening Match")); @@ -2090,7 +2158,7 @@ private: /** * Tracks focus of widgets (vte and rFind) in this terminal pane */ - bool onTerminalWidgetFocusIn(Event event, Widget widget) { + bool onTerminalWidgetFocusIn(EventFocus event, Widget widget) { terminalWidgetFocusIn(widget); return false; } @@ -2098,7 +2166,7 @@ private: void terminalWidgetFocusIn(Widget widget) { trace("Terminal gained focus " ~ uuid); lblTitle.setSensitive(true); - bTitle.setStateFlags(StateFlags.ACTIVE, false); + bTitle.setStateFlags(StateFlags.Active, false); //Fire focus events so session can track which terminal last had focus onFocusIn.emit(this); // Set colors for dimPercent @@ -2108,7 +2176,7 @@ private: /** * Tracks focus of widgets (vte and rFind) in this terminal pane */ - bool onTerminalWidgetFocusOut(Event event, Widget widget) { + bool onTerminalWidgetFocusOut(EventFocus event, Widget widget) { terminalWidgetFocusOut(widget); return false; } @@ -2117,7 +2185,7 @@ private: trace("Terminal lost focus " ~ uuid); lblTitle.setSensitive(isTerminalWidgetFocused()); if (!isTerminalWidgetFocused()) { - bTitle.unsetStateFlags(StateFlags.ACTIVE); + bTitle.unsetStateFlags(StateFlags.Active); } // Set colors for dimPercent setVTEColors(); @@ -2211,12 +2279,12 @@ private: // tracef("vteBGUsed: %f, %f, %f, %f", vteBG.red, vteBG.green, vteBG.blue, vteBG.alpha); if (isTerminalWidgetFocused() || dimPercent == 0) { // tracef("vteFG: %f, %f, %f", vteFG.red, vteFG.green, vteFG.blue); - vte.setColors(vteFG, vteBG, vtePalette); + setTerminalColors(vte, vteFG, vteBG, vtePalette); setBoldColor(vteBold); currentColorSet = VTEColorSet.normal; } else { // tracef("dimFG: %f, %f, %f", dimFG.red, dimFG.green, dimFG.blue); - vte.setColors(dimFG, vteBG, dimPalette); + setTerminalColors(vte, dimFG, vteBG, dimPalette); setBoldColor(dimBold); currentColorSet = VTEColorSet.dim; } @@ -2248,8 +2316,8 @@ private: case SETTINGS_PROFILE_FG_COLOR_KEY, SETTINGS_PROFILE_BG_COLOR_KEY, SETTINGS_PROFILE_PALETTE_COLOR_KEY, SETTINGS_PROFILE_USE_THEME_COLORS_KEY, SETTINGS_PROFILE_BG_TRANSPARENCY_KEY, SETTINGS_PROFILE_DIM_TRANSPARENCY_KEY: if (gsProfile.getBoolean(SETTINGS_PROFILE_USE_THEME_COLORS_KEY)) { - getStyleColor(vte.getStyleContext(), StateFlags.ACTIVE, vteFG); - getStyleBackgroundColor(vte.getStyleContext(), StateFlags.ACTIVE, vteBG); + getStyleColor(vte.getStyleContext(), StateFlags.Active, vteFG); + getStyleBackgroundColor(vte.getStyleContext(), StateFlags.Active, vteBG); } else { if (!vteFG.parse(gsProfile.getString(SETTINGS_PROFILE_FG_COLOR_KEY))) trace("Parsing foreground color failed"); @@ -2257,7 +2325,8 @@ private: trace("Parsing background color failed"); } vteBG.alpha = to!double(100 - gsProfile.getInt(SETTINGS_PROFILE_BG_TRANSPARENCY_KEY)) / 100.0; - string[] colors = gsProfile.getStrv(SETTINGS_PROFILE_PALETTE_COLOR_KEY); + // Use workaround for GID 0.9.7 getStrv bug that returns only 1 element + string[] colors = getSettingsStrv(gsProfile, SETTINGS_PROFILE_PALETTE_COLOR_KEY); foreach (i, color; colors) { if (!vtePalette[i].parse(color)) { trace("Parsing color failed " ~ colors[i]); @@ -2317,9 +2386,9 @@ private: case SETTINGS_PROFILE_SHOW_SCROLLBAR_KEY: if (useOverlayScrollbar) { if (gsProfile.getBoolean(SETTINGS_PROFILE_SHOW_SCROLLBAR_KEY)) { - sw.setPolicy(PolicyType.NEVER, PolicyType.AUTOMATIC); + sw.setPolicy(PolicyType.Never, PolicyType.Automatic); } else { - sw.setPolicy(PolicyType.NEVER, PolicyType.NEVER); + sw.setPolicy(PolicyType.Never, PolicyType.Never); } } else { sb.setNoShowAll(!gsProfile.getBoolean(SETTINGS_PROFILE_SHOW_SCROLLBAR_KEY)); @@ -2418,11 +2487,11 @@ private: case SETTINGS_CONTROL_SCROLL_ZOOM_KEY: if (gsSettings.getBoolean(SETTINGS_CONTROL_SCROLL_ZOOM_KEY)) { if (vte !is null && scrollEventHandlerId == 0) { - scrollEventHandlerId = vte.addOnScroll(&onTerminalScroll); + scrollEventHandlerId = vte.connectScrollEvent(&onTerminalScroll); } } else { if (vte !is null && scrollEventHandlerId > 0) { - Signals.handlerDisconnect(vte, scrollEventHandlerId); + signalHandlerDisconnect(vte, scrollEventHandlerId); scrollEventHandlerId = 0; } } @@ -2519,29 +2588,29 @@ private: } } - VteTextBlinkMode getTextBlinkMode(string mode) { + TextBlinkMode getTextBlinkMode(string mode) { long i = countUntil(SETTINGS_PROFILE_TEXT_BLINK_MODE_VALUES, mode); return cast(VteTextBlinkMode) i; } - VteCursorBlinkMode getBlinkMode(string mode) { + CursorBlinkMode getBlinkMode(string mode) { long i = countUntil(SETTINGS_PROFILE_CURSOR_BLINK_MODE_VALUES, mode); return cast(VteCursorBlinkMode) i; } - VteEraseBinding getEraseBinding(string binding) { + EraseBinding getEraseBinding(string binding) { long i = countUntil(SETTINGS_PROFILE_ERASE_BINDING_VALUES, binding); return cast(VteEraseBinding) i; } - VteCursorShape getCursorShape(string shape) { + CursorShape getCursorShape(string shape) { final switch (shape) { case SETTINGS_PROFILE_CURSOR_SHAPE_BLOCK_VALUE: - return VteCursorShape.BLOCK; + return VteCursorShape.Block; case SETTINGS_PROFILE_CURSOR_SHAPE_IBEAM_VALUE: - return VteCursorShape.IBEAM; + return VteCursorShape.Ibeam; case SETTINGS_PROFILE_CURSOR_SHAPE_UNDERLINE_VALUE: - return VteCursorShape.UNDERLINE; + return VteCursorShape.Underline; } } @@ -2567,9 +2636,9 @@ private: foreach (i, regex; compiledVRegex) { int id = vte.matchAddRegex(cast(VRegex) regex, 0); regexTag[id] = URL_REGEX_PATTERNS[i]; - vte.matchSetCursorType(id, CursorType.HAND2); + vte.matchSetCursorType(id, CursorType.Hand2); } - } catch (GException e) { + } catch (ErrorWrap e) { errorf(_("Unexpected error occurred when adding link regex: %s"), e.msg); } } @@ -2606,10 +2675,10 @@ private: if (compiledRegex !is null) { int id = vte.matchAddRegex(compiledRegex, 0); regexTag[id] = regex; - vte.matchSetCursorType(id, CursorType.HAND2); + vte.matchSetCursorType(id, CursorType.Hand2); tracef("Added regex: %s with tag %d",value[0], id); } - } catch (GException ge) { + } catch (ErrorWrap ge) { error(format(_("Custom link regex '%s' has an error, ignoring"), regex)); error(ge.msg); } @@ -2622,21 +2691,21 @@ private: void feedChild(string text, bool ignoreCommit) { if (USE_COMMIT_SYNCHRONIZATION) { if (ignoreCommit) { - Signals.handlerBlock(vte, _commitHandlerId); + signalHandlerBlock(vte, _commitHandlerId); } } - vte.feedChild(text); + vte.feedChild(cast(ubyte[]) text); if (USE_COMMIT_SYNCHRONIZATION) { if (ignoreCommit) { - Signals.handlerUnblock(vte, _commitHandlerId); + signalHandlerUnblock(vte, _commitHandlerId); } } } void showInfoBarMessage(string message) { TerminalInfoBar ibRelaunch = new TerminalInfoBar(); - ibRelaunch.addOnResponse(delegate(int response, InfoBar ib) { - if (response == ResponseType.OK) { + ibRelaunch.connectResponse(delegate(int response, InfoBar ib) { + if (response == ResponseType.Ok) { ibRelaunch.destroy(); spawnTerminalProcess(gst.initialCWD, _overrideCommand); } @@ -2654,7 +2723,9 @@ private: return; } trace("Current directory: " ~ cwd); - directory = URI.filenameFromUri(cwd, hostname); + string hostnameLocal; + directory = filenameFromUri(cwd, hostnameLocal); + hostname = hostnameLocal; } /** @@ -2691,14 +2762,14 @@ private: trace("Working directory overridden to " ~ workingDir); } if (workingDir.length == 0) { - string cwd = Util.getCurrentDir(); + string cwd = getCurrentDir(); trace("No working directory set, using cwd"); workingDir = cwd; } trace("Spawn setting workingDir to " ~ workingDir); - GSpawnFlags flags = GSpawnFlags.SEARCH_PATH_FROM_ENVP; + GSpawnFlags flags = GSpawnFlags.SearchPathFromEnvp; string shell = null; if (isFlatpak()) { @@ -2707,7 +2778,7 @@ private: shell = "/bin/sh"; } } else { - shell = getUserShell(vte.getUserShell()); + shell = getUserShell(environment.get("SHELL", "/bin/sh")); } string[] args; @@ -2719,16 +2790,16 @@ private: //keep copy of command around _overrideCommand = command; trace("Overriding the command from command prompt: " ~ command); - ShellUtils.shellParseArgv(command, args); - flags = flags | GSpawnFlags.SEARCH_PATH; + shellParseArgv(command, args); + flags = flags | GSpawnFlags.SearchPath; } else if (gsProfile.getBoolean(SETTINGS_PROFILE_USE_CUSTOM_COMMAND_KEY)) { - ShellUtils.shellParseArgv(gsProfile.getString(SETTINGS_PROFILE_CUSTOM_COMMAND_KEY), args); - flags = flags | GSpawnFlags.SEARCH_PATH; + shellParseArgv(gsProfile.getString(SETTINGS_PROFILE_CUSTOM_COMMAND_KEY), args); + flags = flags | GSpawnFlags.SearchPath; } else { args ~= shell; if (gsProfile.getBoolean(SETTINGS_PROFILE_LOGIN_SHELL_KEY)) { args ~= format("-%s", shell); - flags = flags | GSpawnFlags.FILE_AND_ARGV_ZERO; + flags = flags | GSpawnFlags.FileAndArgvZero; } } string[] envv = ["TILIX_ID=" ~ uuid]; @@ -2779,7 +2850,7 @@ private: } } } - catch (GException ge) { + catch (ErrorWrap ge) { string msg = format(_("Unexpected error occurred: %s"), ge.msg); outputError(msg, workingDir, args, envv); showInfoBarMessage(msg); @@ -2827,7 +2898,7 @@ private: */ bool spawnSync(string workingDir, string[] args, string[] envv, GSpawnFlags flags, out int gpid) { if (isFlatpak()) { - Pty pty = vte.ptyNewSync(VtePtyFlags.DEFAULT, null); + Pty pty = vte.ptyNewSync(VtePtyFlags.Default, null); int pty_master = pty.getFd(); @@ -2855,10 +2926,10 @@ private: pty_slaves ~= core.sys.posix.unistd.dup(pty_slaves[0]); } - import VteVersion = vte.Version; + import vte.global : getMinorVersion, getMicroVersion; envv ~= ["TERM=" ~"xterm-256color"]; - envv ~= [format("VTE_VERSION=%02u%02u", VteVersion.Version.getMinorVersion(), VteVersion.Version.getMicroVersion())]; + envv ~= [format("VTE_VERSION=%02u%02u", getMinorVersion(), getMicroVersion())]; string[] igneredEnvv = [ "PATH", @@ -2893,28 +2964,37 @@ private: return result; } else { - return vte.spawnSync(VtePtyFlags.DEFAULT, workingDir, args, envv, flags, null, null, gpid, null); + int childPid; + bool result = vte.spawnSync(VtePtyFlags.Default, workingDir, args, envv, flags, null, childPid, null); + gpid = childPid; + return result; } } GVariant buildHostCommandVariant(string workingDir, string[] args, string[] envv, uint[] handles) { - if (workingDir.length == 0) workingDir = Util.getHomeDir(); + if (workingDir.length == 0) workingDir = getHomeDir(); GVariantBuilder fdBuilder = new GVariantBuilder(new GVariantType("a{uh}")); foreach(i, fd; handles) { - fdBuilder.addValue(new GVariant(new GVariant(i), new GVariant(g_variant_new_handle(fd), true))); + auto keyVar = new GVariant(cast(uint)i); + auto handleVar = new GVariant(g_variant_new_handle(fd), true); + auto dictEntry = GVariant.newDictEntry(keyVar, handleVar); + fdBuilder.addValue(dictEntry); } GVariantBuilder envBuilder = new GVariantBuilder(new GVariantType("a{ss}")); foreach(env; envv) { string[] envPair = env.split("="); tracef("Adding env var %s=%s", envPair[0], envPair[1]); if (envPair.length ==2) { - GVariant pair = new GVariant(new GVariant(envPair[0]), new GVariant(envPair[1])); + auto keyVar = new GVariant(envPair[0]); + auto valVar = new GVariant(envPair[1]); + GVariant pair = GVariant.newDictEntry(keyVar, valVar); envBuilder.addValue(pair); } } - import gtkc.glib: g_variant_new; + import glib.c.functions: g_variant_new; + import glib.c.types: GVariant; immutable(char)* wd = toStringz(workingDir); immutable(char)*[] argsv; @@ -2924,14 +3004,19 @@ private: argsv ~= null; - gtkc.glibtypes.GVariant* vs = g_variant_new("(^ay^aay@a{uh}@a{ss}u)", + import glib.c.types : GVariant_ = GVariant; + auto fdEndVar = fdBuilder.end(); + auto envEndVar = envBuilder.end(); + GVariant_* vs = g_variant_new("(^ay^aay@a{uh}@a{ss}u)", wd, argsv.ptr, - fdBuilder.end().getVariantStruct(true), - envBuilder.end().getVariantStruct(true), + cast(GVariant_*)fdEndVar._cPtr(), + cast(GVariant_*)envEndVar._cPtr(), cast(uint) 1); - return new GVariant(vs, true); + import gid.gid : Yes; + import glib.variant : Variant; + return new Variant(cast(void*)vs, Yes.Take); } alias HostCommandExitedCallback = void delegate(int); @@ -2944,12 +3029,14 @@ private: }; extern(C) static void hostCommandExitedCallback(GDBusConnection *connection, const(char)* senderName, const(char)* objectPath, const(char)* interfaceName, - const(char)* signalName, gtkc.glibtypes.GVariant* parameters, HostCommandExitedArgs *args) { + const(char)* signalName, void* parameters, HostCommandExitedArgs *args) { + import glib.c.types : GVariant_ = GVariant; + import glib.c.functions : c_g_variant_get = g_variant_get; uint pid, status; - g_variant_get(parameters, "(uu)", &pid, &status); + c_g_variant_get(cast(GVariant_*)parameters, "(uu)", &pid, &status); if (args.pid == -1 || pid == args.pid) { - import gtkc.gio: g_dbus_connection_signal_unsubscribe; + import gio.c.functions: g_dbus_connection_signal_unsubscribe; if (args.pid == -1) { trace("hostCommandExitedCallback was called before spawn completed."); @@ -2967,8 +3054,9 @@ private: } bool sendHostCommand(string workingDir, string[] args, string[] envv, int[] stdio_fds, out int gpid, HostCommandExitedCallback exitedCallback) { - import gio.DBusConnection; - import gio.UnixFDList; + import gio.dbus_connection : DBusConnection; + import gio.unix_fdlist : UnixFDList; + import gio.types : DBusConnectionFlags, DBusSignalFlags, DBusCallFlags; uint[] handles; @@ -2981,29 +3069,49 @@ private: } } - DBusConnection connection = new DBusConnection( + DBusConnection connection = DBusConnection.newForAddressSync( environment.get("DBUS_SESSION_BUS_ADDRESS"), - GDBusConnectionFlags.AUTHENTICATION_CLIENT | GDBusConnectionFlags.MESSAGE_BUS_CONNECTION, + DBusConnectionFlags.AuthenticationClient | DBusConnectionFlags.MessageBusConnection, null, null ); connection.setExitOnClose(false); - connection.doref(); + // Keep the connection alive - we need to store it + // connection is already ref'd by the wrapper auto callbackArgs = new HostCommandExitedArgs(); callbackArgs.callback = exitedCallback; GC.addRoot(cast(void*)callbackArgs); + // Use a D delegate for signalSubscribe that wraps the callback logic uint signalId = connection.signalSubscribe( "org.freedesktop.Flatpak", "org.freedesktop.Flatpak.Development", "HostCommandExited", "/org/freedesktop/Flatpak/Development", null, - DBusSignalFlags.NONE, - cast(GDBusSignalCallback)&hostCommandExitedCallback, - cast(void*)callbackArgs, - null, + DBusSignalFlags.None, + delegate(DBusConnection conn, string senderName, string objectPath, string interfaceName, string signalName, GVariant parameters) { + import glib.c.types : GVariant_ = GVariant; + import glib.c.functions : c_g_variant_get = g_variant_get; + uint pid, status; + c_g_variant_get(cast(GVariant_*)parameters._cPtr(), "(uu)", &pid, &status); + + if (callbackArgs.pid == -1 || pid == callbackArgs.pid) { + if (callbackArgs.pid == -1) { + trace("hostCommandExitedCallback was called before spawn completed."); + callbackArgs.pid = pid; + callbackArgs.status = status; + } else { + conn.signalUnsubscribe(callbackArgs.signalId); + callbackArgs.callback(status); + } + + GC.removeRoot(cast(void*)callbackArgs); + warning("**********COLLECT**********"); + GC.collect(); + } + } ); GVariant reply = connection.callWithUnixFdListSync( @@ -3013,7 +3121,7 @@ private: "HostCommand", buildHostCommandVariant(workingDir, args, envv, handles), new GVariantType("(u)"), - GDBusCallFlags.NONE, + DBusCallFlags.None, -1, inFdList, outFdList, @@ -3026,7 +3134,9 @@ private: return false; } else { uint pid; - g_variant_get(reply.getVariantStruct(), "(u)", &pid); + import glib.c.types : GVariant_ = GVariant; + import glib.c.functions : c_g_variant_get = g_variant_get; + c_g_variant_get(cast(GVariant_*)reply._cPtr(), "(u)", &pid); gpid = pid; if (callbackArgs.pid != -1) { @@ -3048,11 +3158,12 @@ private: */ string captureHostToolboxCommand(string command, string arg, int[] extra_fds) { import std.process: Pipe, pipe; - import glib.MainContext; - import glib.KeyFile; + import glib.main_context : MainContext; + import glib.key_file : KeyFile; + import glib.types : KeyFileFlags; KeyFile kf = new KeyFile(); - kf.loadFromFile("/.flatpak-info", GKeyFileFlags.NONE); + kf.loadFromFile("/.flatpak-info", KeyFileFlags.None); string hostRoot = kf.getString("Instance", "app-path"); string[] args = [format("%s/bin/tilix-flatpak-toolbox", hostRoot), command, arg]; @@ -3163,36 +3274,36 @@ private: void setupDragAndDrop(Widget title) { trace("Setting up drag and drop"); //DND - TargetEntry uriEntry = new TargetEntry("text/uri-list", TargetFlags.OTHER_APP, DropTargets.URILIST); - TargetEntry stringEntry = new TargetEntry("STRING", TargetFlags.OTHER_APP, DropTargets.STRING); - TargetEntry textEntry = new TargetEntry("text/plain", TargetFlags.OTHER_APP, DropTargets.TEXT); - TargetEntry utf8TextEntry = new TargetEntry("UTF8_STRING", TargetFlags.OTHER_APP, DropTargets.UTF8_TEXT); - TargetEntry colorEntry = new TargetEntry("application/x-color", TargetFlags.OTHER_APP, DropTargets.COLOR); - TargetEntry vteEntry = new TargetEntry(VTE_DND, TargetFlags.SAME_APP, DropTargets.VTE); - TargetEntry sessionEntry = new TargetEntry(SESSION_DND, TargetFlags.SAME_APP, DropTargets.SESSION); + TargetEntry uriEntry = new TargetEntry("text/uri-list", TargetFlags.OtherApp, DropTargets.URILIST); + TargetEntry stringEntry = new TargetEntry("STRING", TargetFlags.OtherApp, DropTargets.STRING); + TargetEntry textEntry = new TargetEntry("text/plain", TargetFlags.OtherApp, DropTargets.TEXT); + TargetEntry utf8TextEntry = new TargetEntry("UTF8_STRING", TargetFlags.OtherApp, DropTargets.UTF8_TEXT); + TargetEntry colorEntry = new TargetEntry("application/x-color", TargetFlags.OtherApp, DropTargets.COLOR); + TargetEntry vteEntry = new TargetEntry(VTE_DND, TargetFlags.SameApp, DropTargets.VTE); + TargetEntry sessionEntry = new TargetEntry(SESSION_DND, TargetFlags.SameApp, DropTargets.SESSION); TargetEntry[] targets = [uriEntry, utf8TextEntry, stringEntry, textEntry, colorEntry, vteEntry, sessionEntry]; - vte.dragDestSet(DestDefaults.ALL, targets, DragAction.COPY | DragAction.MOVE); - dragSourceSet(ModifierType.BUTTON1_MASK, [vteEntry], DragAction.MOVE); + vte.dragDestSet(DestDefaults.All, targets, GdkDragAction.Copy | GdkDragAction.Move); + dragSourceSet(ModifierType.Button1Mask, [vteEntry], GdkDragAction.Move); //Title bar events - addOnDragBegin(&onTitleDragBegin); - addOnDragDataGet(&onTitleDragDataGet); - addOnDragFailed(&onTitleDragFailed, ConnectFlags.AFTER); - addOnDragEnd(&onTitleDragEnd, ConnectFlags.AFTER); + connectDragBegin(&onTitleDragBegin); + connectDragDataGet(&onTitleDragDataGet); + connectDragFailed(&onTitleDragFailed, Yes.After); + connectDragEnd(&onTitleDragEnd, Yes.After); //VTE Drop events - vte.addOnDragDataReceived(&onVTEDragDataReceived); - vte.addOnDragMotion(&onVTEDragMotion); - vte.addOnDragLeave(&onVTEDragLeave); + vte.connectDragDataReceived(&onVTEDragDataReceived); + vte.connectDragMotion(&onVTEDragMotion); + vte.connectDragLeave(&onVTEDragLeave); if (checkVTEVersion(VTE_VERSION_BACKGROUND_OPERATOR)) { vte.setClearBackground(false); } //TODO - Figure out why this is causing issues, see #545 if (isVTEBackgroundDrawEnabled()) { - vte.addOnDraw(&onVTEDrawBadge); + vte.connectDraw(&onVTEDrawBadge); } - vte.addOnDraw(&onVTEDraw, ConnectFlags.AFTER); + vte.connectDraw(&onVTEDraw, Yes.After); trace("Drag and drop completed"); } @@ -3203,16 +3314,16 @@ private: */ void onTitleDragDataGet(DragContext dc, SelectionData data, uint info, uint time, Widget widget) { char[] buffer = (uuid ~ '\0').dup; - GdkAtom gdkAtom = data.getTarget(); - string name = gdk.Atom.name(gdkAtom); - if (name == "application/x-rootwindow-drop") { + Atom gdkAtom = data.getTarget(); + string atomNameStr = gdkAtom.name(); + if (atomNameStr == "application/x-rootwindow-drop") { trace("Root window drop"); isRootWindow = true; } else { - tracef("onTitleDragDataGet atom: %s", name); + tracef("onTitleDragDataGet atom: %s", atomNameStr); isRootWindow = false; } - data.set(intern(VTE_DND, false), 8, buffer); + data.set(Atom.intern(VTE_DND, false), 8, cast(ubyte[])buffer); } /** @@ -3235,13 +3346,13 @@ private: } static if (USE_PIXBUF_DND) { dragImage = getWidgetImage(this, 0.20); - DragAndDrop.dragSetIconPixbuf(dc, dragImage, 0, 0); + dragSetIconPixbuf(dc, dragImage, 0, 0); } else { - Image image = new Image(getWidgetImage(this, 0.20)); + Image image = Image.newFromPixbuf(getWidgetImage(this, 0.20)); image.show(); - dragImage = new Window(GtkWindowType.POPUP); + dragImage = new Window(GtkWindowType.Popup); dragImage.add(image); - DragAndDrop.dragSetIconWidget(dc, dragImage, 0, 0); + dragSetIconWidget(dc, dragImage, 0, 0); } } @@ -3257,7 +3368,7 @@ private: dragImage = null; } // Under Wayland needed to fix cursor sticking due to - // GtkD holding reference to GTK DragReference + // GTK binding holding reference to GTK DragContext dc.destroy(); } @@ -3299,7 +3410,7 @@ private: } Terminal getDragTerminal(DragContext dc) { - Terminal terminal = cast(Terminal) DragAndDrop.dragGetSourceWidget(dc); + Terminal terminal = cast(Terminal) dragGetSourceWidget(dc); if (terminal is null) { error("Oops, something went wrong not a terminal drag"); return null; @@ -3318,7 +3429,25 @@ private: */ bool onVTEDragMotion(DragContext dc, int x, int y, uint time, Widget widget) { //Is this a terminal drag or something else? - if (!dc.listTargets().find(intern(VTE_DND, false))) { + // Note: listTargets is not wrapped in GID, so we use C API + import gdk.c.functions : gdk_drag_context_list_targets; + import gdk.c.types : GdkDragContext; + import glib.c.types : GList; + + auto targetsList = gdk_drag_context_list_targets(cast(GdkDragContext*)dc._cPtr); + bool foundVteDnd = false; + auto vteDndAtom = Atom.intern(VTE_DND, false); + + // Iterate through GList to find VTE_DND + for (auto l = targetsList; l !is null; l = l.next) { + auto targetAtom = new Atom(l.data, No.Take); + if (targetAtom.name() == VTE_DND) { + foundVteDnd = true; + break; + } + } + + if (!foundVteDnd) { return true; } //Don't allow drop on the same terminal or if it is maximized @@ -3410,10 +3539,10 @@ private: trace("Converted filename " ~ filename); } else { string hostname; - filename = URI.filenameFromUri(uri, hostname); + filename = filenameFromUri(uri, hostname); } - string quoted = ShellUtils.shellQuote(filename) ~ " "; - vte.feedChild(quoted); + string quoted = shellQuote(filename) ~ " "; + vte.feedChild(cast(ubyte[])quoted.dup); } } break; @@ -3421,12 +3550,13 @@ private: string text = data.getText(); tracef("Text dropped %s,%d,%d", text, text.length, data.getLength); if (text.length > 0) { - vte.feedChild(text); + vte.feedChild(cast(ubyte[])text.dup); } break; case DropTargets.COLOR: if (data.getLength() != 8) return; - char[] colors = data.getDataWithLength(); + ubyte[] rawData = data.getData(); + char[] colors = cast(char[])rawData; string hexColor = format("#%02X%02X%02X", colors[0], colors[1], colors[2]); trace("Hex Color " ~ hexColor); tracef("Red=%d,Green=%d,Blue=%d,Alpha=%d", colors[0], colors[1], colors[2], colors[3]); @@ -3437,14 +3567,16 @@ private: //Don't allow drop on the same terminal if (isSourceAndDestEqual(dc, this) || terminalWindowState == TerminalWindowState.MAXIMIZED) return; - string uuid = to!string(data.getDataWithLength()[0 .. $ - 1]); + ubyte[] rawData = data.getData(); + string uuid = to!string(cast(char[])rawData[0 .. $ - 1]); DragQuadrant dq = getDragQuadrant(x, y, vte); tracef("Receiving Terminal %s, Dropped terminal %s, x=%d, y=%d, dq=%d", _terminalUUID, uuid, x, y, dq); notifyTerminalRequestMove(uuid, this, dq); dragInfo = DragInfo(false, dq); break; case DropTargets.SESSION: - string uuid = to!string(data.getDataWithLength()[0 .. $ - 1]); + ubyte[] rawData2 = data.getData(); + string uuid = to!string(cast(char[])rawData2[0 .. $ - 1]); notifySessionRequestAttach(uuid); break; } @@ -3475,7 +3607,7 @@ private: vte.queueDraw(); } - bool onVTEDrawBadge(Scoped!Context cr, Widget w) { + bool onVTEDrawBadge(Context cr, Widget w) { cr.save(); double width = to!double(w.getAllocatedWidth()); double height = to!double(w.getAllocatedHeight()); @@ -3494,7 +3626,7 @@ private: } else { cr.setSourceRgba(vteBG.red, vteBG.green, vteBG.blue, vteBG.alpha); } - cr.setOperator(cairo_operator_t.SOURCE); + cr.setOperator(Operator.Source); cr.rectangle(0.0, 0.0, width, height); cr.clip(); cr.paint(); @@ -3540,8 +3672,8 @@ private: PgLayout pgl = new PgLayout(vte.getPangoContext()); pgl.setFontDescription(badgeFont); pgl.setText(_cachedBadge); - pgl.setWidth(rect.width * PANGO_SCALE); - pgl.setHeight(rect.height * PANGO_SCALE); + pgl.setWidth(rect.width * SCALE); + pgl.setHeight(rect.height * SCALE); int pw, ph; pgl.getPixelSize(pw, ph); @@ -3561,23 +3693,23 @@ private: //tracef("Width %d, Pixel Width %d, Pixel Height %d, Original Font ratio %f, Font size %d", rect.width, pw, ph, fontRatio, fontSize); pgl.getPixelSize(pw, ph); } else { - pgl.setWrap(PangoWrapMode.WORD_CHAR); + pgl.setWrap(WrapMode.WordChar); } */ /**************************************************/ - pgl.setWrap(PangoWrapMode.WORD_CHAR); + pgl.setWrap(WrapMode.WordChar); switch (position) { case SETTINGS_QUADRANT_NE_VALUE: - pgl.setAlignment(PangoAlignment.RIGHT); + pgl.setAlignment(Alignment.Right); break; case SETTINGS_QUADRANT_SW_VALUE: rect.y = rect.y + rect.height - ph; break; case SETTINGS_QUADRANT_SE_VALUE: rect.y = rect.y + rect.height - ph; - pgl.setAlignment(PangoAlignment.RIGHT); + pgl.setAlignment(Alignment.Right); break; default: } @@ -3586,7 +3718,7 @@ private: cr.clip(); cr.moveTo(rect.x, rect.y); - PgCairo.showLayout(cr, pgl); + showLayout(cr, pgl); cr.resetClip(); } @@ -3598,7 +3730,7 @@ private: enum STROKE_WIDTH = 4; //Draw the drag hint if dragging is occurring - bool onVTEDraw(Scoped!Context cr, Widget widget) { + bool onVTEDraw(Context cr, Widget widget) { /* if (dimPercent > 0) { Window window = cast(Window) getToplevel(); @@ -3617,7 +3749,7 @@ private: RGBA color; if (!vte.getStyleContext().lookupColor("theme_selected_bg_color", color)) { - getStyleBackgroundColor(vte.getStyleContext(), StateFlags.SELECTED, color); + getStyleBackgroundColor(vte.getStyleContext(), StateFlags.Selected, color); } cr.setSourceRgba(color.red, color.green, color.blue, 1.0); cr.setLineWidth(STROKE_WIDTH); @@ -3654,15 +3786,23 @@ private: * showSaveAsDialog = Determines if save as dialog is shown. Note dialog may be shown even if false is passed if the session filename is not set */ void saveTerminalOutput(bool showSaveAsDialog = true) { - import gio.OutputStream : OutputStream; - if (outputFilename.length == 0 || showSaveAsDialog) { Window window = cast(Window) getToplevel(); - FileChooserDialog fcd = new FileChooserDialog( - _("Save Terminal Output"), - window, - FileChooserAction.SAVE, - [_("Save"), _("Cancel")]); + + import gtk.c.functions : gtk_file_chooser_dialog_new; + import gtk.c.types : GtkFileChooserAction, GtkWidget, GtkWindow; + import std.typecons : No; + import std.string : toStringz; + + GtkWidget* widget = gtk_file_chooser_dialog_new( + toStringz(_("Save Terminal Output")), + cast(GtkWindow*) window._cPtr(), + GtkFileChooserAction.Save, + toStringz(_("_Cancel")), ResponseType.Cancel, + toStringz(_("_Save")), ResponseType.Ok, + null + ); + FileChooserDialog fcd = new FileChooserDialog(cast(void*) widget, No.Take); scope (exit) fcd.destroy(); @@ -3676,25 +3816,25 @@ private: fcd.addFilter(ff); fcd.setDoOverwriteConfirmation(true); - fcd.setDefaultResponse(ResponseType.OK); + fcd.setDefaultResponse(ResponseType.Ok); if (outputFilename.length == 0) { } else { fcd.setCurrentName("output.txt"); } - if (fcd.run() == ResponseType.OK) { + if (fcd.run() == ResponseType.Ok) { outputFilename = fcd.getFilename(); } else { return; } } //Do work here - GFileIF file = parseName(outputFilename); - OutputStream stream = file.replace(null, false, GFileCreateFlags.NONE, null); + File file = parseName(outputFilename); + OutputStream stream = file.replace(null, false, GFileCreateFlags.None, null); scope (exit) { stream.close(null); } - vte.writeContentsSync(stream, VteWriteFlags.DEFAULT, null); + vte.writeContentsSync(stream, WriteFlags.Default, null); } // Theme changed @@ -3750,7 +3890,7 @@ public: */ this(string profileUUID, string requestedUUID) { super(); - addOnDestroy(delegate(Widget) { + connectDestroy((Widget w) { //trace("Terminal destroyed"); finalizeTerminal(); }); @@ -3776,13 +3916,13 @@ public: } gsSettings = new GSettings(SETTINGS_ID); - gsSettings.addOnChanged(delegate(string key, GSettings) { applyPreference(key); }); + gsSettings.connectChanged(null, (string key, GSettings s) { applyPreference(key); }); gsProfile = prfMgr.getProfileSettings(_activeProfileUUID); monitorSilence = gsProfile.getBoolean(SETTINGS_PROFILE_NOTIFY_ENABLED_KEY); gsShortcuts = new GSettings(SETTINGS_KEY_BINDINGS_ID); gsDesktop = new GSettings(SETTINGS_DESKTOP_ID); - gsDesktop.addOnChanged(delegate(string key, GSettings) { + gsDesktop.connectChanged(null, (string key, GSettings s) { if (key == SETTINGS_MONOSPACE_FONT_KEY) { applyPreference(SETTINGS_PROFILE_FONT_KEY); } @@ -3791,7 +3931,7 @@ public: trace("Apply preferences"); applyPreferences(); trace("Profile Event Handler"); - gsProfile.addOnChanged(delegate(string key, Settings) { + gsProfile.connectChanged(null, (string key, GSettings s) { applyPreference(key); }); // notified when theme changed @@ -3846,7 +3986,7 @@ public: if (vte !is null) { foreach(handler; vteHandlers) { if (handler > 0) { - Signals.handlerDisconnect(vte, handler); + signalHandlerDisconnect(vte, handler); handler = 0; } } @@ -3875,7 +4015,7 @@ public: if (vte !is null && !inDestruction()) { //Workaround for #589 - import gtk.Bin; + import gtk.bin : Bin; Bin bin = cast(Bin)vte.getParent(); if (bin !is null) { bin.remove(vte); @@ -4135,13 +4275,20 @@ public: gsProfile.destroy(); gsProfile = prfMgr.getProfileSettings(_activeProfileUUID); // Hook up change event - gsProfile.addOnChanged(delegate(string key, Settings) { + gsProfile.connectChanged(null, (string key, GSettings s) { applyPreference(key); }); applyPreferences(); } } + void executeAction(string actionName) { + SimpleAction action = cast(SimpleAction) sagTerminalActions.lookupAction(actionName); + if (action !is null) { + action.activate(null); + } + } + @property bool synchronizeInput() { return _synchronizeInput; } @@ -4270,17 +4417,18 @@ private: public: this() { - super([_("Relaunch")], [ResponseType.OK]); + super(); + addButton(_("Relaunch"), ResponseType.Ok); lblPrompt = new Label(""); getContentArea().packStart(lblPrompt, true, true, 0); - lblPrompt.setHalign(GtkAlign.START); - setHalign(GtkAlign.FILL); - setValign(GtkAlign.START); + lblPrompt.setHalign(Align.Start); + setHalign(Align.Fill); + setValign(Align.Start); trace("Infobar created"); - addOnMap(delegate(Widget) { - setDefaultResponse(ResponseType.OK); - setMessageType(MessageType.QUESTION); - }, ConnectFlags.AFTER); + connectMap(delegate(Widget w) { + setDefaultResponse(ResponseType.Ok); + setMessageType(MessageType.Question); + }, Yes.After); } void setMessage(string message) { @@ -4311,34 +4459,43 @@ package class UnsafePasteDialog : MessageDialog { public: this(Window parent, string cmd) { - super(parent, DialogFlags.MODAL, MessageType.WARNING, ButtonsType.NONE, null, null); + // Use C API to create MessageDialog since GID doesn't have convenience constructor + import gtk.c.functions : gtk_message_dialog_new; + import gtk.c.types : GtkMessageDialog, GtkDialogFlags, GtkMessageType, GtkButtonsType; + auto ptr = gtk_message_dialog_new( + parent ? cast(GtkWindow*)parent._cPtr() : null, + cast(GtkDialogFlags)(DialogFlags.Modal), + cast(GtkMessageType)(MessageType.Warning), + cast(GtkButtonsType)(ButtonsType.None), + null); + super(cast(void*)ptr, Yes.Take); setTransientFor(parent); getMessageArea().setMarginLeft(0); getMessageArea().setMarginRight(0); string[3] msg = getUnsafePasteMessage(); setMarkup("" ~ msg[0] ~ "\n\n" ~ msg[1] ~ "\n" ~ msg[2] ~ "\n" ); - setImage(new Image("dialog-warning", IconSize.DIALOG)); + setImage(Image.newFromIconName("dialog-warning", IconSize.Dialog)); - Label lblCmd = new Label(SimpleXML.markupEscapeText(cmd, cmd.length)); + Label lblCmd = new Label(markupEscapeText(cmd, cmd.length)); lblCmd.setUseMarkup(true); - lblCmd.setHalign(GtkAlign.START); - lblCmd.setEllipsize(PangoEllipsizeMode.END); + lblCmd.setHalign(Align.Start); + lblCmd.setEllipsize(EllipsizeMode.End); if (count(cmd,"\n") > 6) { ScrolledWindow sw = new ScrolledWindow(); - sw.setShadowType(ShadowType.ETCHED_IN); - sw.setPolicy(PolicyType.AUTOMATIC, PolicyType.AUTOMATIC); + sw.setShadowType(ShadowType.EtchedIn); + sw.setPolicy(PolicyType.Automatic, PolicyType.Automatic); sw.setHexpand(true); sw.setVexpand(true); sw.setSizeRequest(400, 140); sw.add(lblCmd); - getMessageArea().add(sw); + (cast(Container)getMessageArea()).add(sw); } else { - getMessageArea().add(lblCmd); + (cast(Container)getMessageArea()).add(lblCmd); } - Button btnCancel = new Button(_("Don't Paste")); - Button btnIgnore = new Button(_("Paste Anyway")); + Button btnCancel = Button.newWithLabel(_("Don't Paste")); + Button btnIgnore = Button.newWithLabel(_("Paste Anyway")); btnIgnore.getStyleContext().addClass("destructive-action"); addActionWidget(btnCancel, 1); addActionWidget(btnIgnore, 0); diff --git a/source/secret/Collection.d b/source/secret/Collection.d deleted file mode 100644 index 784784925..000000000 --- a/source/secret/Collection.d +++ /dev/null @@ -1,881 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secret.Collection; - -private import gio.AsyncInitableIF; -private import gio.AsyncInitableT; -private import gio.AsyncResultIF; -private import gio.Cancellable; -private import gio.DBusInterfaceIF; -private import gio.DBusInterfaceT; -private import gio.DBusProxy; -private import gio.InitableIF; -private import gio.InitableT; -private import glib.ConstructionException; -private import glib.ErrorG; -private import glib.GException; -private import glib.HashTable; -private import glib.ListG; -private import glib.Str; -private import gobject.ObjectG; -private import secret.Schema; -private import secret.Service; -private import secretc.secret; -public import secretc.secrettypes; - - -/** - * A proxy object representing a collection of secrets in the Secret Service. - */ -public class Collection : DBusProxy -{ - /** the main Gtk struct */ - protected SecretCollection* secretCollection; - - /** Get the main Gtk struct */ - public SecretCollection* getCollectionStruct() - { - return secretCollection; - } - - /** the main Gtk struct as a void* */ - protected override void* getStruct() - { - return cast(void*)secretCollection; - } - - /** - * Sets our main struct and passes it to the parent class. - */ - public this (SecretCollection* secretCollection, bool ownedRef = false) - { - this.secretCollection = secretCollection; - super(cast(GDBusProxy*)secretCollection, ownedRef); - } - - - /** */ - public static GType getType() - { - return secret_collection_get_type(); - } - - /** - * Finish asynchronous operation to get a new collection proxy for a - * collection in the secret service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: the new collection, which should be unreferenced - * with g_object_unref() - * - * Throws: GException on failure. - * Throws: ConstructionException GTK+ fails to create the object. - */ - public this(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_collection_new_for_dbus_path_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - throw new ConstructionException("null returned by new_for_dbus_path_finish"); - } - - this(cast(SecretCollection*) p, true); - } - - /** - * Get a new collection proxy for a collection in the secret service. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * service = a secret service object - * collectionPath = the D-Bus path of the collection - * flags = options for the collection initialization - * cancellable = optional cancellation object - * - * Return: the new collection, which should be unreferenced - * with g_object_unref() - * - * Throws: GException on failure. - * Throws: ConstructionException GTK+ fails to create the object. - */ - public this(Service service, string collectionPath, SecretCollectionFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_collection_new_for_dbus_path_sync((service is null) ? null : service.getServiceStruct(), Str.toStringz(collectionPath), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - throw new ConstructionException("null returned by new_for_dbus_path_sync"); - } - - this(cast(SecretCollection*) p, true); - } - - /** - * Create a new collection in the secret service. - * - * This method returns immediately and completes asynchronously. The secret - * service may prompt the user. secret_service_prompt() will be used to handle - * any prompts that are required. - * - * An @alias is a well-known tag for a collection, such as 'default' (ie: the - * default collection to store items in). This allows other applications to - * easily identify and share a collection. If you specify an @alias, and a - * collection with that alias already exists, then a new collection will not - * be created. The previous one will be returned instead. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * Params: - * service = a secret service object - * label = label for the new collection - * alias_ = alias to assign to the collection - * flags = currently unused - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public static void create(Service service, string label, string alias_, SecretCollectionCreateFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_collection_create((service is null) ? null : service.getServiceStruct(), Str.toStringz(label), Str.toStringz(alias_), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish operation to create a new collection in the secret service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: the new collection, which should be unreferenced - * with g_object_unref() - * - * Throws: GException on failure. - */ - public static Collection createFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_collection_create_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Collection)(cast(SecretCollection*) p, true); - } - - /** - * Create a new collection in the secret service. - * - * This method may block indefinitely and should not be used in user interface - * threads. The secret service may prompt the user. secret_service_prompt() - * will be used to handle any prompts that are required. - * - * An @alias is a well-known tag for a collection, such as 'default' (ie: the - * default collection to store items in). This allows other applications to - * easily identify and share a collection. If you specify an @alias, and a - * collection with that alias already exists, then a new collection will not - * be created. The previous one will be returned instead. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * Params: - * service = a secret service object - * label = label for the new collection - * alias_ = alias to assign to the collection - * flags = currently unused - * cancellable = optional cancellation object - * - * Return: the new collection, which should be unreferenced - * with g_object_unref() - * - * Throws: GException on failure. - */ - public static Collection createSync(Service service, string label, string alias_, SecretCollectionCreateFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_collection_create_sync((service is null) ? null : service.getServiceStruct(), Str.toStringz(label), Str.toStringz(alias_), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Collection)(cast(SecretCollection*) p, true); - } - - /** - * Lookup which collection is assigned to this alias. Aliases help determine - * well known collections, such as 'default'. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * service = a secret service object - * alias_ = the alias to lookup - * flags = options for the collection initialization - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public static void forAlias(Service service, string alias_, SecretCollectionFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_collection_for_alias((service is null) ? null : service.getServiceStruct(), Str.toStringz(alias_), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish an asynchronous operation to lookup which collection is assigned - * to an alias. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: the collection, or %NULL if none assigned to the alias - * - * Throws: GException on failure. - */ - public static Collection forAliasFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_collection_for_alias_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Collection)(cast(SecretCollection*) p, true); - } - - /** - * Lookup which collection is assigned to this alias. Aliases help determine - * well known collections, such as 'default'. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block and should not be used in user interface threads. - * - * Params: - * service = a secret service object - * alias_ = the alias to lookup - * flags = options for the collection initialization - * cancellable = optional cancellation object - * - * Return: the collection, or %NULL if none assigned to the alias - * - * Throws: GException on failure. - */ - public static Collection forAliasSync(Service service, string alias_, SecretCollectionFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_collection_for_alias_sync((service is null) ? null : service.getServiceStruct(), Str.toStringz(alias_), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Collection)(cast(SecretCollection*) p, true); - } - - /** - * Get a new collection proxy for a collection in the secret service. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * service = a secret service object - * collectionPath = the D-Bus path of the collection - * flags = options for the collection initialization - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public static void newForDbusPath(Service service, string collectionPath, SecretCollectionFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_collection_new_for_dbus_path((service is null) ? null : service.getServiceStruct(), Str.toStringz(collectionPath), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Delete this collection. - * - * This method returns immediately and completes asynchronously. The secret - * service may prompt the user. secret_service_prompt() will be used to handle - * any prompts that show up. - * - * Params: - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void delet(Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_collection_delete(secretCollection, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete operation to delete this collection. - * - * Params: - * result = asynchronous result passed to the callback - * - * Return: whether the collection was successfully deleted or not - * - * Throws: GException on failure. - */ - public bool deleteFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_collection_delete_finish(secretCollection, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Delete this collection. - * - * This method may block indefinitely and should not be used in user - * interface threads. The secret service may prompt the user. - * secret_service_prompt() will be used to handle any prompts that show up. - * - * Params: - * cancellable = optional cancellation object - * - * Return: whether the collection was successfully deleted or not - * - * Throws: GException on failure. - */ - public bool deleteSync(Cancellable cancellable) - { - GError* err = null; - - auto p = secret_collection_delete_sync(secretCollection, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Get the created date and time of the collection. The return value is - * the number of seconds since the unix epoch, January 1st 1970. - * - * Return: the created date and time - */ - public ulong getCreated() - { - return secret_collection_get_created(secretCollection); - } - - /** - * Get the list of items in this collection. - * - * Return: a list of items, - * when done, the list should be freed with g_list_free, and each item should - * be released with g_object_unref() - */ - public ListG getItems() - { - auto p = secret_collection_get_items(secretCollection); - - if(p is null) - { - return null; - } - - return new ListG(cast(GList*) p, true); - } - - /** - * Get the label of this collection. - * - * Return: the label, which should be freed with g_free() - */ - public string getLabel() - { - auto retStr = secret_collection_get_label(secretCollection); - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Get whether the collection is locked or not. - * - * Use secret_service_lock() or secret_service_unlock() to lock or unlock the - * collection. - * - * Return: whether the collection is locked or not - */ - public bool getLocked() - { - return secret_collection_get_locked(secretCollection) != 0; - } - - /** - * Get the modified date and time of the collection. The return value is - * the number of seconds since the unix epoch, January 1st 1970. - * - * Return: the modified date and time - */ - public ulong getModified() - { - return secret_collection_get_modified(secretCollection); - } - - /** - * Get the Secret Service object that this collection was created with. - * - * Return: the Secret Service object - */ - public Service getService() - { - auto p = secret_collection_get_service(secretCollection); - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Service)(cast(SecretService*) p); - } - - /** - * Ensure that the #SecretCollection proxy has loaded all the items present - * in the Secret Service. This affects the result of - * secret_collection_get_items(). - * - * For collections returned from secret_service_get_collections() the items - * will have already been loaded. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void loadItems(Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_collection_load_items(secretCollection, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete an asynchronous operation to ensure that the #SecretCollection proxy - * has loaded all the items present in the Secret Service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: whether the load was successful or not - * - * Throws: GException on failure. - */ - public bool loadItemsFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_collection_load_items_finish(secretCollection, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Ensure that the #SecretCollection proxy has loaded all the items present - * in the Secret Service. This affects the result of - * secret_collection_get_items(). - * - * For collections returned from secret_service_get_collections() the items - * will have already been loaded. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * cancellable = optional cancellation object - * - * Return: whether the load was successful or not - * - * Throws: GException on failure. - */ - public bool loadItemsSync(Cancellable cancellable) - { - GError* err = null; - - auto p = secret_collection_load_items_sync(secretCollection, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Refresh the properties on this collection. This fires off a request to - * refresh, and the properties will be updated later. - * - * Calling this method is not normally necessary, as the secret service - * will notify the client when properties change. - */ - public void refresh() - { - secret_collection_refresh(secretCollection); - } - - /** - * Search for items matching the @attributes in the @collection. - * The @attributes should be a table of string keys and string values. - * - * If %SECRET_SEARCH_ALL is set in @flags, then all the items matching the - * search will be returned. Otherwise only the first item will be returned. - * This is almost always the unlocked item that was most recently stored. - * - * If %SECRET_SEARCH_UNLOCK is set in @flags, then items will be unlocked - * if necessary. In either case, locked and unlocked items will match the - * search and be returned. If the unlock fails, the search does not fail. - * - * If %SECRET_SEARCH_LOAD_SECRETS is set in @flags, then the items will have - * their secret values loaded and available via secret_item_get_secret(). - * - * This function returns immediately and completes asynchronously. - * - * Params: - * schema = the schema for the attributes - * attributes = search for items matching these attributes - * flags = search option flags - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void search(Schema schema, HashTable attributes, SecretSearchFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_collection_search(secretCollection, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to search for items in a collection. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: a list of items that matched the search - * - * Throws: GException on failure. - */ - public ListG searchFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_collection_search_finish(secretCollection, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new ListG(cast(GList*) p, true); - } - - /** - * Search for items in @collection matching the @attributes, and return their - * DBus object paths. Only the specified collection is searched. The @attributes - * should be a table of string keys and string values. - * - * This function returns immediately and completes asynchronously. - * - * When your callback is called use secret_collection_search_for_dbus_paths_finish() - * to get the results of this function. Only the DBus object paths of the - * items will be returned. If you would like #SecretItem objects to be returned - * instead, then use the secret_collection_search() function. - * - * Params: - * schema = the schema for the attributes - * attributes = search for items matching these attributes - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void searchForDbusPaths(Schema schema, HashTable attributes, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_collection_search_for_dbus_paths(secretCollection, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to search for items in a collection. - * - * DBus object paths of the items will be returned. If you would to have - * #SecretItem objects to be returned instead, then use the - * secret_collection_search() and secret_collection_search_finish() functions. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: an array of DBus object - * paths for matching items. - * - * Throws: GException on failure. - */ - public string[] searchForDbusPathsFinish(AsyncResultIF result) - { - GError* err = null; - - auto retStr = secret_collection_search_for_dbus_paths_finish(secretCollection, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeStringArray(retStr); - return Str.toStringArray(retStr); - } - - /** - * Search for items matching the @attributes in @collection, and return their - * DBus object paths. The @attributes should be a table of string keys and - * string values. - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * DBus object paths of the items will be returned. If you would to have - * #SecretItem objects to be returned instead, then use the - * secret_collection_search_sync() function. - * - * Params: - * schema = the schema for the attributes - * attributes = search for items matching these attributes - * cancellable = optional cancellation object - * - * Return: an array of DBus object - * paths for matching items. - * - * Throws: GException on failure. - */ - public string[] searchForDbusPathsSync(Schema schema, HashTable attributes, Cancellable cancellable) - { - GError* err = null; - - auto retStr = secret_collection_search_for_dbus_paths_sync(secretCollection, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeStringArray(retStr); - return Str.toStringArray(retStr); - } - - /** - * Search for items matching the @attributes in the @collection. - * The @attributes should be a table of string keys and string values. - * - * If %SECRET_SEARCH_ALL is set in @flags, then all the items matching the - * search will be returned. Otherwise only the first item will be returned. - * This is almost always the unlocked item that was most recently stored. - * - * If %SECRET_SEARCH_UNLOCK is set in @flags, then items will be unlocked - * if necessary. In either case, locked and unlocked items will match the - * search and be returned. If the unlock fails, the search does not fail. - * - * If %SECRET_SEARCH_LOAD_SECRETS is set in @flags, then the items will have - * their secret values loaded and available via secret_item_get_secret(). - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * Params: - * schema = the schema for the attributes - * attributes = search for items matching these attributes - * flags = search option flags - * cancellable = optional cancellation object - * - * Return: a list of items that matched the search - * - * Throws: GException on failure. - */ - public ListG searchSync(Schema schema, HashTable attributes, SecretSearchFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_collection_search_sync(secretCollection, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new ListG(cast(GList*) p, true); - } - - /** - * Set the label of this collection. - * - * This function returns immediately and completes asynchronously. - * - * Params: - * label = a new label - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void setLabel(string label, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_collection_set_label(secretCollection, Str.toStringz(label), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to set the label of this collection. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: whether the change was successful or not - * - * Throws: GException on failure. - */ - public bool setLabelFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_collection_set_label_finish(secretCollection, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Set the label of this collection. - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * Params: - * label = a new label - * cancellable = optional cancellation object - * - * Return: whether the change was successful or not - * - * Throws: GException on failure. - */ - public bool setLabelSync(string label, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_collection_set_label_sync(secretCollection, Str.toStringz(label), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } -} diff --git a/source/secret/Item.d b/source/secret/Item.d deleted file mode 100644 index 291389d54..000000000 --- a/source/secret/Item.d +++ /dev/null @@ -1,861 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secret.Item; - -private import gio.AsyncInitableIF; -private import gio.AsyncInitableT; -private import gio.AsyncResultIF; -private import gio.Cancellable; -private import gio.DBusInterfaceIF; -private import gio.DBusInterfaceT; -private import gio.DBusProxy; -private import gio.InitableIF; -private import gio.InitableT; -private import glib.ConstructionException; -private import glib.ErrorG; -private import glib.GException; -private import glib.HashTable; -private import glib.ListG; -private import glib.Str; -private import gobject.ObjectG; -private import secret.Collection; -private import secret.Schema; -private import secret.Service; -private import secret.Value; -private import secretc.secret; -public import secretc.secrettypes; - - -/** - * A proxy object representing a secret item in the Secret Service. - */ -public class Item : DBusProxy -{ - /** the main Gtk struct */ - protected SecretItem* secretItem; - - /** Get the main Gtk struct */ - public SecretItem* getItemStruct() - { - return secretItem; - } - - /** the main Gtk struct as a void* */ - protected override void* getStruct() - { - return cast(void*)secretItem; - } - - /** - * Sets our main struct and passes it to the parent class. - */ - public this (SecretItem* secretItem, bool ownedRef = false) - { - this.secretItem = secretItem; - super(cast(GDBusProxy*)secretItem, ownedRef); - } - - - /** */ - public static GType getType() - { - return secret_item_get_type(); - } - - /** - * Finish asynchronous operation to get a new item proxy for an secret - * item in the secret service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: the new item, which should be unreferenced - * with g_object_unref() - * - * Throws: GException on failure. - * Throws: ConstructionException GTK+ fails to create the object. - */ - public this(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_item_new_for_dbus_path_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - throw new ConstructionException("null returned by new_for_dbus_path_finish"); - } - - this(cast(SecretItem*) p, true); - } - - /** - * Get a new item proxy for a secret item in the secret service. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * service = a secret service object - * itemPath = the D-Bus path of the item - * flags = initialization flags for the new item - * cancellable = optional cancellation object - * - * Return: the new item, which should be unreferenced - * with g_object_unref() - * - * Throws: GException on failure. - * Throws: ConstructionException GTK+ fails to create the object. - */ - public this(Service service, string itemPath, SecretItemFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_item_new_for_dbus_path_sync((service is null) ? null : service.getServiceStruct(), Str.toStringz(itemPath), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - throw new ConstructionException("null returned by new_for_dbus_path_sync"); - } - - this(cast(SecretItem*) p, true); - } - - /** - * Create a new item in the secret service. - * - * If the @flags contains %SECRET_ITEM_CREATE_REPLACE, then the secret - * service will search for an item matching the @attributes, and update that item - * instead of creating a new one. - * - * This method may block indefinitely and should not be used in user interface - * threads. The secret service may prompt the user. secret_service_prompt() - * will be used to handle any prompts that are required. - * - * Params: - * collection = a secret collection to create this item in - * schema = the schema for the attributes - * attributes = attributes for the new item - * label = label for the new item - * value = secret value for the new item - * flags = flags for the creation of the new item - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public static void create(Collection collection, Schema schema, HashTable attributes, string label, Value value, SecretItemCreateFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_item_create((collection is null) ? null : collection.getCollectionStruct(), (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), Str.toStringz(label), (value is null) ? null : value.getValueStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish operation to create a new item in the secret service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: the new item, which should be unreferenced - * with g_object_unref() - * - * Throws: GException on failure. - */ - public static Item createFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_item_create_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Item)(cast(SecretItem*) p, true); - } - - /** - * Create a new item in the secret service. - * - * If the @flags contains %SECRET_ITEM_CREATE_REPLACE, then the secret - * service will search for an item matching the @attributes, and update that item - * instead of creating a new one. - * - * This method may block indefinitely and should not be used in user interface - * threads. The secret service may prompt the user. secret_service_prompt() - * will be used to handle any prompts that are required. - * - * Params: - * collection = a secret collection to create this item in - * schema = the schema for the attributes - * attributes = attributes for the new item - * label = label for the new item - * value = secret value for the new item - * flags = flags for the creation of the new item - * cancellable = optional cancellation object - * - * Return: the new item, which should be unreferenced - * with g_object_unref() - * - * Throws: GException on failure. - */ - public static Item createSync(Collection collection, Schema schema, HashTable attributes, string label, Value value, SecretItemCreateFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_item_create_sync((collection is null) ? null : collection.getCollectionStruct(), (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), Str.toStringz(label), (value is null) ? null : value.getValueStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Item)(cast(SecretItem*) p, true); - } - - /** - * Load the secret values for an secret items stored in the service. - * - * The @items must all have the same SecretItem::service property. - * - * This function returns immediately and completes asynchronously. - * - * Params: - * items = the items to retrieve secrets for - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public static void loadSecrets(ListG items, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_item_load_secrets((items is null) ? null : items.getListGStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to load the secret values for - * secret items stored in the service. - * - * Items that are locked will not have their secrets loaded. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: whether the operation succeeded or not - * - * Throws: GException on failure. - */ - public static bool loadSecretsFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_item_load_secrets_finish((result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Load the secret values for an secret items stored in the service. - * - * The @items must all have the same SecretItem::service property. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Items that are locked will not have their secrets loaded. - * - * Params: - * items = the items to retrieve secrets for - * cancellable = optional cancellation object - * - * Return: whether the operation succeeded or not - * - * Throws: GException on failure. - */ - public static bool loadSecretsSync(ListG items, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_item_load_secrets_sync((items is null) ? null : items.getListGStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Get a new item proxy for a secret item in the secret service. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * service = a secret service object - * itemPath = the D-Bus path of the collection - * flags = initialization flags for the new item - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public static void newForDbusPath(Service service, string itemPath, SecretItemFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_item_new_for_dbus_path((service is null) ? null : service.getServiceStruct(), Str.toStringz(itemPath), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Delete this item. - * - * This method returns immediately and completes asynchronously. The secret - * service may prompt the user. secret_service_prompt() will be used to handle - * any prompts that show up. - * - * Params: - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void delet(Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_item_delete(secretItem, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to delete the secret item. - * - * Params: - * result = asynchronous result passed to the callback - * - * Return: whether the item was successfully deleted or not - * - * Throws: GException on failure. - */ - public bool deleteFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_item_delete_finish(secretItem, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Delete this secret item. - * - * This method may block indefinitely and should not be used in user - * interface threads. The secret service may prompt the user. - * secret_service_prompt() will be used to handle any prompts that show up. - * - * Params: - * cancellable = optional cancellation object - * - * Return: whether the item was successfully deleted or not - * - * Throws: GException on failure. - */ - public bool deleteSync(Cancellable cancellable) - { - GError* err = null; - - auto p = secret_item_delete_sync(secretItem, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Set the attributes of this item. - * - * The @attributes are a mapping of string keys to string values. - * Attributes are used to search for items. Attributes are not stored - * or transferred securely by the secret service. - * - * Do not modify the attributes returned by this method. Use - * secret_item_set_attributes() instead. - * - * Return: a new reference - * to the attributes, which should not be modified, and - * released with g_hash_table_unref() - */ - public HashTable getAttributes() - { - auto p = secret_item_get_attributes(secretItem); - - if(p is null) - { - return null; - } - - return new HashTable(cast(GHashTable*) p, true); - } - - /** - * Get the created date and time of the item. The return value is - * the number of seconds since the unix epoch, January 1st 1970. - * - * Return: the created date and time - */ - public ulong getCreated() - { - return secret_item_get_created(secretItem); - } - - /** - * Get the label of this item. - * - * Return: the label, which should be freed with g_free() - */ - public string getLabel() - { - auto retStr = secret_item_get_label(secretItem); - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Get whether the item is locked or not. - * - * Depending on the secret service an item may not be able to be locked - * independently from the collection that it is in. - * - * Return: whether the item is locked or not - */ - public bool getLocked() - { - return secret_item_get_locked(secretItem) != 0; - } - - /** - * Get the modified date and time of the item. The return value is - * the number of seconds since the unix epoch, January 1st 1970. - * - * Return: the modified date and time - */ - public ulong getModified() - { - return secret_item_get_modified(secretItem); - } - - /** - * Gets the name of the schema that this item was stored with. This is also - * available at the xdg:schema attribute. - * - * Return: the schema name - */ - public string getSchemaName() - { - auto retStr = secret_item_get_schema_name(secretItem); - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Get the secret value of this item. If this item is locked or the secret - * has not yet been loaded then this will return %NULL. - * - * To load the secret call the secret_item_load_secret() method. - * - * Return: the secret value which should be - * released with secret_value_unref(), or %NULL - */ - public Value getSecret() - { - auto p = secret_item_get_secret(secretItem); - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Value)(cast(SecretValue*) p, true); - } - - /** - * Get the Secret Service object that this item was created with. - * - * Return: the Secret Service object - */ - public Service getService() - { - auto p = secret_item_get_service(secretItem); - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Service)(cast(SecretService*) p); - } - - /** - * Load the secret value of this item. - * - * Each item has a single secret which might be a password or some - * other secret binary value. - * - * This function will fail if the secret item is locked. - * - * This function returns immediately and completes asynchronously. - * - * Params: - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void loadSecret(Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_item_load_secret(secretItem, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to load the secret value of this item. - * - * The newly loaded secret value can be accessed by calling - * secret_item_get_secret(). - * - * Params: - * result = asynchronous result passed to callback - * - * Return: whether the secret item successfully loaded or not - * - * Throws: GException on failure. - */ - public bool loadSecretFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_item_load_secret_finish(secretItem, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Load the secret value of this item. - * - * Each item has a single secret which might be a password or some - * other secret binary value. - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * Params: - * cancellable = optional cancellation object - * - * Return: whether the secret item successfully loaded or not - * - * Throws: GException on failure. - */ - public bool loadSecretSync(Cancellable cancellable) - { - GError* err = null; - - auto p = secret_item_load_secret_sync(secretItem, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Refresh the properties on this item. This fires off a request to - * refresh, and the properties will be updated later. - * - * Calling this method is not normally necessary, as the secret service - * will notify the client when properties change. - */ - public void refresh() - { - secret_item_refresh(secretItem); - } - - /** - * Set the attributes of this item. - * - * The @attributes are a mapping of string keys to string values. - * Attributes are used to search for items. Attributes are not stored - * or transferred securely by the secret service. - * - * This function returns immediately and completes asynchronously. - * - * Params: - * schema = the schema for the attributes - * attributes = a new set of attributes - * cancellable = optional cancellation object - * callback = called when the asynchronous operation completes - * userData = data to pass to the callback - */ - public void setAttributes(Schema schema, HashTable attributes, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_item_set_attributes(secretItem, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete operation to set the attributes of this item. - * - * Params: - * result = asynchronous result passed to the callback - * - * Return: whether the change was successful or not - * - * Throws: GException on failure. - */ - public bool setAttributesFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_item_set_attributes_finish(secretItem, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Set the attributes of this item. - * - * The @attributes are a mapping of string keys to string values. - * Attributes are used to search for items. Attributes are not stored - * or transferred securely by the secret service. - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * Params: - * schema = the schema for the attributes - * attributes = a new set of attributes - * cancellable = optional cancellation object - * - * Return: whether the change was successful or not - * - * Throws: GException on failure. - */ - public bool setAttributesSync(Schema schema, HashTable attributes, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_item_set_attributes_sync(secretItem, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Set the label of this item. - * - * This function returns immediately and completes asynchronously. - * - * Params: - * label = a new label - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void setLabel(string label, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_item_set_label(secretItem, Str.toStringz(label), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to set the label of this collection. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: whether the change was successful or not - * - * Throws: GException on failure. - */ - public bool setLabelFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_item_set_label_finish(secretItem, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Set the label of this item. - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * Params: - * label = a new label - * cancellable = optional cancellation object - * - * Return: whether the change was successful or not - * - * Throws: GException on failure. - */ - public bool setLabelSync(string label, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_item_set_label_sync(secretItem, Str.toStringz(label), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Set the secret value of this item. - * - * Each item has a single secret which might be a password or some - * other secret binary value. - * - * This function returns immediately and completes asynchronously. - * - * Params: - * value = a new secret value - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void setSecret(Value value, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_item_set_secret(secretItem, (value is null) ? null : value.getValueStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to set the secret value of this item. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: whether the change was successful or not - * - * Throws: GException on failure. - */ - public bool setSecretFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_item_set_secret_finish(secretItem, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Set the secret value of this item. - * - * Each item has a single secret which might be a password or some - * other secret binary value. - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * Params: - * value = a new secret value - * cancellable = optional cancellation object - * - * Return: whether the change was successful or not - * - * Throws: GException on failure. - */ - public bool setSecretSync(Value value, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_item_set_secret_sync(secretItem, (value is null) ? null : value.getValueStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } -} diff --git a/source/secret/Prompt.d b/source/secret/Prompt.d deleted file mode 100644 index c2de795f7..000000000 --- a/source/secret/Prompt.d +++ /dev/null @@ -1,227 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secret.Prompt; - -private import gio.AsyncInitableIF; -private import gio.AsyncInitableT; -private import gio.AsyncResultIF; -private import gio.Cancellable; -private import gio.DBusInterfaceIF; -private import gio.DBusInterfaceT; -private import gio.DBusProxy; -private import gio.InitableIF; -private import gio.InitableT; -private import glib.ErrorG; -private import glib.GException; -private import glib.Str; -private import glib.Variant; -private import glib.VariantType; -private import secretc.secret; -public import secretc.secrettypes; - - -/** - * A proxy object representing a prompt that the Secret Service will display - * to the user. - */ -public class Prompt : DBusProxy -{ - /** the main Gtk struct */ - protected SecretPrompt* secretPrompt; - - /** Get the main Gtk struct */ - public SecretPrompt* getPromptStruct() - { - return secretPrompt; - } - - /** the main Gtk struct as a void* */ - protected override void* getStruct() - { - return cast(void*)secretPrompt; - } - - /** - * Sets our main struct and passes it to the parent class. - */ - public this (SecretPrompt* secretPrompt, bool ownedRef = false) - { - this.secretPrompt = secretPrompt; - super(cast(GDBusProxy*)secretPrompt, ownedRef); - } - - - /** */ - public static GType getType() - { - return secret_prompt_get_type(); - } - - /** - * Runs a prompt and performs the prompting. Returns %TRUE if the prompt - * was completed and not dismissed. - * - * If @window_id is non-null then it is used as an XWindow id on Linux. The API - * expects this id to be converted to a string using the %d - * printf format. The Secret Service can make its prompt transient for the window - * with this id. In some Secret Service implementations this is not possible, so - * the behavior depending on this should degrade gracefully. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * windowId = string form of XWindow id for parent window to be transient for - * returnType = the variant type of the prompt result - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void perform(string windowId, VariantType returnType, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_prompt_perform(secretPrompt, Str.toStringz(windowId), (returnType is null) ? null : returnType.getVariantTypeStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to run a prompt and perform the prompting. - * - * Returns a variant result if the prompt was completed and not dismissed. The - * type of result depends on the action the prompt is completing, and is - * defined in the Secret Service DBus API specification. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: %NULL if the prompt was dismissed or an error occurred, - * a variant result if the prompt was successful - * - * Throws: GException on failure. - */ - public Variant performFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_prompt_perform_finish(secretPrompt, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new Variant(cast(GVariant*) p, true); - } - - /** - * Runs a prompt and performs the prompting. Returns a variant result if the - * prompt was completed and not dismissed. The type of result depends on the - * action the prompt is completing, and is defined in the Secret Service DBus - * API specification. - * - * If @window_id is non-null then it is used as an XWindow id on Linux. The API - * expects this id to be converted to a string using the %d - * printf format. The Secret Service can make its prompt transient for the window - * with this id. In some Secret Service implementations this is not possible, - * so the behavior depending on this should degrade gracefully. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * windowId = string form of XWindow id for parent window to be transient for - * cancellable = optional cancellation object - * returnType = the variant type of the prompt result - * - * Return: %NULL if the prompt was dismissed or an error occurred - * - * Throws: GException on failure. - */ - public Variant performSync(string windowId, Cancellable cancellable, VariantType returnType) - { - GError* err = null; - - auto p = secret_prompt_perform_sync(secretPrompt, Str.toStringz(windowId), (cancellable is null) ? null : cancellable.getCancellableStruct(), (returnType is null) ? null : returnType.getVariantTypeStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new Variant(cast(GVariant*) p, true); - } - - /** - * Runs a prompt and performs the prompting. Returns a variant result if the - * prompt was completed and not dismissed. The type of result depends on the - * action the prompt is completing, and is defined in the Secret Service DBus - * API specification. - * - * If @window_id is non-null then it is used as an XWindow id on Linux. The API - * expects this id to be converted to a string using the %d - * printf format. The Secret Service can make its prompt transient for the window - * with this id. In some Secret Service implementations this is not possible, so - * the behavior depending on this should degrade gracefully. - * - * This runs the dialog in a recursive mainloop. When run from a user interface - * thread, this means the user interface will remain responsive. Care should be - * taken that appropriate user interface actions are disabled while running the - * prompt. - * - * Params: - * windowId = string form of XWindow id for parent window to be transient for - * cancellable = optional cancellation object - * returnType = the variant type of the prompt result - * - * Return: %NULL if the prompt was dismissed or an error occurred - * - * Throws: GException on failure. - */ - public Variant run(string windowId, Cancellable cancellable, VariantType returnType) - { - GError* err = null; - - auto p = secret_prompt_run(secretPrompt, Str.toStringz(windowId), (cancellable is null) ? null : cancellable.getCancellableStruct(), (returnType is null) ? null : returnType.getVariantTypeStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new Variant(cast(GVariant*) p, true); - } -} diff --git a/source/secret/Schema.d b/source/secret/Schema.d deleted file mode 100644 index e94fb17f8..000000000 --- a/source/secret/Schema.d +++ /dev/null @@ -1,174 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secret.Schema; - -private import glib.ConstructionException; -private import glib.HashTable; -private import glib.Str; -private import gobject.ObjectG; -private import secretc.secret; -public import secretc.secrettypes; - - -/** - * Represents a set of attributes that are stored with an item. These schemas - * are used for interoperability between various services storing the same types - * of items. - * - * Each schema has a name like "org.gnome.keyring.NetworkPassword", and defines - * a set of attributes, and types (string, integer, boolean) for those attributes. - * - * Attributes are stored as strings in the Secret Service, and the attribute - * types simply define standard ways to store integer and boolean values as strings. - * Attributes are represented in libsecret via a #GHashTable with string keys and - * values. Even for values that defined as an integer or boolean in the schema, - * the attribute values in the #GHashTable are strings. Boolean values are stored - * as the strings 'true' and 'false'. Integer values are stored in decimal, with - * a preceding negative sign for negative integers. - * - * Schemas are handled entirely on the client side by this library. The name of the - * schema is automatically stored as an attribute on the item. - * - * Normally when looking up passwords only those with matching schema names are - * returned. If the schema @flags contain the %SECRET_SCHEMA_DONT_MATCH_NAME flag, - * then lookups will not check that the schema name matches that on the item, only - * the schema's attributes are matched. This is useful when you are looking up items - * that are not stored by the libsecret library. Other libraries such as libgnome-keyring - * don't store the schema name. - */ -public class Schema -{ - /** the main Gtk struct */ - protected SecretSchema* secretSchema; - protected bool ownedRef; - - /** Get the main Gtk struct */ - public SecretSchema* getSchemaStruct() - { - return secretSchema; - } - - /** the main Gtk struct as a void* */ - protected void* getStruct() - { - return cast(void*)secretSchema; - } - - /** - * Sets our main struct and passes it to the parent class. - */ - public this (SecretSchema* secretSchema, bool ownedRef = false) - { - this.secretSchema = secretSchema; - this.ownedRef = ownedRef; - } - - - /** */ - public static GType getType() - { - return secret_schema_get_type(); - } - - /** - * Using this function is not normally necessary from C code. This is useful - * for constructing #SecretSchema structures in bindings. - * - * A schema represents a set of attributes that are stored with an item. These - * schemas are used for interoperability between various services storing the - * same types of items. - * - * Each schema has an @name like "org.gnome.keyring.NetworkPassword", and - * defines a set of attributes names, and types (string, integer, boolean) for - * those attributes. - * - * Each key in the @attributes table should be a attribute name strings, and - * the values in the table should be integers from the #SecretSchemaAttributeType - * enumeration, representing the attribute type for each attribute name. - * - * Normally when looking up passwords only those with matching schema names are - * returned. If the schema @flags contain the %SECRET_SCHEMA_DONT_MATCH_NAME flag, - * then lookups will not check that the schema name matches that on the item, only - * the schema's attributes are matched. This is useful when you are looking up items - * that are not stored by the libsecret library. Other libraries such as libgnome-keyring - * don't store the schema name. - * - * Params: - * name = the dotted name of the schema - * flags = the flags for the schema - * attributeNamesAndTypes = the attribute names and types of those attributes - * - * Return: the new schema, which should be unreferenced with - * secret_schema_unref() when done - * - * Throws: ConstructionException GTK+ fails to create the object. - */ - public this(string name, SecretSchemaFlags flags, HashTable attributeNamesAndTypes) - { - auto p = secret_schema_newv(Str.toStringz(name), flags, (attributeNamesAndTypes is null) ? null : attributeNamesAndTypes.getHashTableStruct()); - - if(p is null) - { - throw new ConstructionException("null returned by newv"); - } - - this(cast(SecretSchema*) p); - } - - /** - * Adds a reference to the #SecretSchema. - * - * It is not normally necessary to call this function from C code, and is - * mainly present for the sake of bindings. If the @schema was statically - * allocated, then this function will copy the schema. - * - * Return: the referenced schema, which should be later - * unreferenced with secret_schema_unref() - */ - public Schema doref() - { - auto p = secret_schema_ref(secretSchema); - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Schema)(cast(SecretSchema*) p, true); - } - - /** - * Releases a reference to the #SecretSchema. If the last reference is - * released then the schema will be freed. - * - * It is not normally necessary to call this function from C code, and is - * mainly present for the sake of bindings. It is an error to call this for - * a @schema that was statically allocated. - */ - public void unref() - { - secret_schema_unref(secretSchema); - } -} diff --git a/source/secret/SchemaAttribute.d b/source/secret/SchemaAttribute.d deleted file mode 100644 index 604aebe61..000000000 --- a/source/secret/SchemaAttribute.d +++ /dev/null @@ -1,42 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secret.SchemaAttribute; - -private import secretc.secret; -public import secretc.secrettypes; - - -/** - * An attribute in a #SecretSchema. - */ -public struct SchemaAttribute -{ - - /** */ - public static GType getType() - { - return secret_schema_attribute_get_type(); - } -} diff --git a/source/secret/Secret.d b/source/secret/Secret.d deleted file mode 100644 index a1de3298f..000000000 --- a/source/secret/Secret.d +++ /dev/null @@ -1,384 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secret.Secret; - -private import gio.AsyncResultIF; -private import gio.Cancellable; -private import glib.ErrorG; -private import glib.GException; -private import glib.HashTable; -private import glib.Str; -private import secret.Schema; -private import secretc.secret; -public import secretc.secrettypes; - - -/** */ -public struct Secret -{ - - /** - * Finish an asynchronous operation to remove passwords from the secret - * service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: whether any passwords were removed - * - * Throws: GException on failure. - */ - public static bool passwordClearFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_password_clear_finish((result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Remove unlocked matching passwords from the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * All unlocked items that match the attributes will be deleted. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * schema = the schema for the attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public static void passwordClearv(Schema schema, HashTable attributes, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_password_clearv((schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Remove unlocked matching passwords from the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * All unlocked items that match the attributes will be deleted. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * schema = the schema for the attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * - * Return: whether any passwords were removed - * - * Throws: GException on failure. - */ - public static bool passwordClearvSync(Schema schema, HashTable attributes, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_password_clearv_sync((schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Clear the memory used by a password, and then free it. - * - * This function must be used to free nonpageable memory returned by - * secret_password_lookup_nonpageable_finish(), - * secret_password_lookup_nonpageable_sync() or - * secret_password_lookupv_nonpageable_sync(). - * - * Params: - * password = password to free - */ - public static void passwordFree(string password) - { - secret_password_free(Str.toStringz(password)); - } - - /** - * Finish an asynchronous operation to lookup a password in the secret service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: a new password string which should be freed with - * secret_password_free() or may be freed with g_free() when done - * - * Throws: GException on failure. - */ - public static string passwordLookupFinish(AsyncResultIF result) - { - GError* err = null; - - auto retStr = secret_password_lookup_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Finish an asynchronous operation to lookup a password in the secret service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: a new password string stored in nonpageable memory - * which must be freed with secret_password_free() when done - * - * Throws: GException on failure. - */ - public static string passwordLookupNonpageableFinish(AsyncResultIF result) - { - GError* err = null; - - auto retStr = secret_password_lookup_nonpageable_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Lookup a password in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If no secret is found then %NULL is returned. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * schema = the schema for attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public static void passwordLookupv(Schema schema, HashTable attributes, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_password_lookupv((schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Lookup a password in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If no secret is found then %NULL is returned. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * schema = the schema for attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * - * Return: a new password string stored in non pageable memory - * which should be freed with secret_password_free() when done - * - * Throws: GException on failure. - */ - public static string passwordLookupvNonpageableSync(Schema schema, HashTable attributes, Cancellable cancellable) - { - GError* err = null; - - auto retStr = secret_password_lookupv_nonpageable_sync((schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Lookup a password in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If no secret is found then %NULL is returned. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * schema = the schema for attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * - * Return: a new password string which should be freed with - * secret_password_free() or may be freed with g_free() when done - * - * Throws: GException on failure. - */ - public static string passwordLookupvSync(Schema schema, HashTable attributes, Cancellable cancellable) - { - GError* err = null; - - auto retStr = secret_password_lookupv_sync((schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Finish asynchronous operation to store a password in the secret service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: whether the storage was successful or not - * - * Throws: GException on failure. - */ - public static bool passwordStoreFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_password_store_finish((result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Store a password in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If the attributes match a secret item already stored in the collection, then - * the item will be updated with these new values. - * - * If @collection is %NULL, then the default collection will be - * used. Use #SECRET_COLLECTION_SESSION to store the password in the session - * collection, which doesn't get stored across login sessions. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * schema = the schema for attributes - * attributes = the attribute keys and values - * collection = a collection alias, or D-Bus object path of the collection where to store the secret - * label = label for the secret - * password = the null-terminated password to store - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public static void passwordStorev(Schema schema, HashTable attributes, string collection, string label, string password, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_password_storev((schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), Str.toStringz(collection), Str.toStringz(label), Str.toStringz(password), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Store a password in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If the attributes match a secret item already stored in the collection, then - * the item will be updated with these new values. - * - * If @collection is %NULL, then the default collection will be - * used. Use #SECRET_COLLECTION_SESSION to store the password in the session - * collection, which doesn't get stored across login sessions. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * schema = the schema for attributes - * attributes = the attribute keys and values - * collection = a collection alias, or D-Bus object path of the collection where to store the secret - * label = label for the secret - * password = the null-terminated password to store - * cancellable = optional cancellation object - * - * Return: whether the storage was successful or not - * - * Throws: GException on failure. - */ - public static bool passwordStorevSync(Schema schema, HashTable attributes, string collection, string label, string password, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_password_storev_sync((schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), Str.toStringz(collection), Str.toStringz(label), Str.toStringz(password), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Clear the memory used by a password. - * - * Params: - * password = password to clear - */ - public static void passwordWipe(string password) - { - secret_password_wipe(Str.toStringz(password)); - } -} diff --git a/source/secret/Service.d b/source/secret/Service.d deleted file mode 100644 index f243a1f14..000000000 --- a/source/secret/Service.d +++ /dev/null @@ -1,2388 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secret.Service; - -private import gio.AsyncInitableIF; -private import gio.AsyncInitableT; -private import gio.AsyncResultIF; -private import gio.Cancellable; -private import gio.DBusInterfaceIF; -private import gio.DBusInterfaceT; -private import gio.DBusProxy; -private import gio.InitableIF; -private import gio.InitableT; -private import glib.ErrorG; -private import glib.GException; -private import glib.HashTable; -private import glib.ListG; -private import glib.Str; -private import glib.Variant; -private import glib.VariantType; -private import gobject.ObjectG; -private import secret.Collection; -private import secret.Prompt; -private import secret.Schema; -private import secret.Value; -private import secretc.secret; -public import secretc.secrettypes; - - -/** - * A proxy object representing the Secret Service. - */ -public class Service : DBusProxy -{ - /** the main Gtk struct */ - protected SecretService* secretService; - - /** Get the main Gtk struct */ - public SecretService* getServiceStruct() - { - return secretService; - } - - /** the main Gtk struct as a void* */ - protected override void* getStruct() - { - return cast(void*)secretService; - } - - /** - * Sets our main struct and passes it to the parent class. - */ - public this (SecretService* secretService, bool ownedRef = false) - { - this.secretService = secretService; - super(cast(GDBusProxy*)secretService, ownedRef); - } - - - /** */ - public static GType getType() - { - return secret_service_get_type(); - } - - /** - * Disconnect the default #SecretService proxy returned by secret_service_get() - * and secret_service_get_sync(). - * - * It is not necessary to call this function, but you may choose to do so at - * program exit. It is useful for testing that memory is not leaked. - * - * This function is safe to call at any time. But if other objects in this - * library are still referenced, then this will not result in all memory - * being freed. - */ - public static void disconnect() - { - secret_service_disconnect(); - } - - /** - * Get a #SecretService proxy for the Secret Service. If such a proxy object - * already exists, then the same proxy is returned. - * - * If @flags contains any flags of which parts of the secret service to - * ensure are initialized, then those will be initialized before completing. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * flags = flags for which service functionality to ensure is initialized - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public static void get(SecretServiceFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_get(flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete an asynchronous operation to get a #SecretService proxy for the - * Secret Service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: a new reference to a #SecretService proxy, which - * should be released with g_object_unref(). - * - * Throws: GException on failure. - */ - public static Service getFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_get_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Service)(cast(SecretService*) p, true); - } - - /** - * Get a #SecretService proxy for the Secret Service. If such a proxy object - * already exists, then the same proxy is returned. - * - * If @flags contains any flags of which parts of the secret service to - * ensure are initialized, then those will be initialized before returning. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * flags = flags for which service functionality to ensure is initialized - * cancellable = optional cancellation object - * - * Return: a new reference to a #SecretService proxy, which - * should be released with g_object_unref(). - * - * Throws: GException on failure. - */ - public static Service getSync(SecretServiceFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_get_sync(flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Service)(cast(SecretService*) p, true); - } - - /** - * Create a new #SecretService proxy for the Secret Service. - * - * This function is rarely used, see secret_service_get() instead. - * - * The @service_gtype argument should be set to %SECRET_TYPE_SERVICE or a the type - * of a derived class. - * - * If @flags contains any flags of which parts of the secret service to - * ensure are initialized, then those will be initialized before returning. - * - * If @service_bus_name is %NULL then the default is used. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * serviceGtype = the GType of the new secret service - * serviceBusName = the D-Bus service name of the secret service - * flags = flags for which service functionality to ensure is initialized - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public static void open(GType serviceGtype, string serviceBusName, SecretServiceFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_open(serviceGtype, Str.toStringz(serviceBusName), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete an asynchronous operation to create a new #SecretService proxy for - * the Secret Service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: a new reference to a #SecretService proxy, which - * should be released with g_object_unref(). - * - * Throws: GException on failure. - */ - public static Service openFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_open_finish((result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Service)(cast(SecretService*) p, true); - } - - /** - * Create a new #SecretService proxy for the Secret Service. - * - * This function is rarely used, see secret_service_get_sync() instead. - * - * The @service_gtype argument should be set to %SECRET_TYPE_SERVICE or a the - * type of a derived class. - * - * If @flags contains any flags of which parts of the secret service to - * ensure are initialized, then those will be initialized before returning. - * - * If @service_bus_name is %NULL then the default is used. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * serviceGtype = the GType of the new secret service - * serviceBusName = the D-Bus service name of the secret service - * flags = flags for which service functionality to ensure is initialized - * cancellable = optional cancellation object - * - * Return: a new reference to a #SecretService proxy, which - * should be released with g_object_unref(). - * - * Throws: GException on failure. - */ - public static Service openSync(GType serviceGtype, string serviceBusName, SecretServiceFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_open_sync(serviceGtype, Str.toStringz(serviceBusName), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Service)(cast(SecretService*) p, true); - } - - /** - * Remove unlocked items which match the attributes from the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * schema = the schema for the attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void clear(Schema schema, HashTable attributes, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_clear(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish asynchronous operation to remove items from the secret - * service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: whether items were removed or not - * - * Throws: GException on failure. - */ - public bool clearFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_clear_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Remove unlocked items which match the attributes from the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * schema = the schema for the attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * - * Return: whether items were removed or not - * - * Throws: GException on failure. - */ - public bool clearSync(Schema schema, HashTable attributes, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_clear_sync(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Create a new collection in the secret service, and return its path. - * - * Using this method requires that you setup a correct hash table of D-Bus - * properties for the new collection. You may prefer to use - * secret_collection_create() which does handles this for you. - * - * An @alias is a well-known tag for a collection, such as 'default' (ie: the - * default collection to store items in). This allows other applications to - * easily identify and share a collection. If a collection with the @alias - * already exists, then instead of creating a new collection, the existing - * collection will be returned. If no collection with this alias exists, then a - * new collection will be created and this alias will be assigned to it. - * - * @properties is a set of properties for the new collection. The keys in the - * hash table should be interface.property strings like - * org.freedesktop.Secret.Collection.Label. The values - * in the hash table should be #GVariant values of the properties. - * - * If you wish to have a - * - * This method will return immediately and complete asynchronously. The secret - * service may prompt the user. secret_service_prompt() will be used to handle - * any prompts that are required. - * - * Params: - * properties = hash table of properties for - * the new collection - * alias_ = an alias to check for before creating the new - * collection, or to assign to the new collection - * flags = not currently used - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void createCollectionDbusPath(HashTable properties, string alias_, SecretCollectionCreateFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_create_collection_dbus_path(secretService, (properties is null) ? null : properties.getHashTableStruct(), Str.toStringz(alias_), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish asynchronous operation to create a new collection in the secret - * service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: a new string containing the D-Bus object path - * of the collection - * - * Throws: GException on failure. - */ - public string createCollectionDbusPathFinish(AsyncResultIF result) - { - GError* err = null; - - auto retStr = secret_service_create_collection_dbus_path_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Create a new collection in the secret service and return its path. - * - * Using this method requires that you setup a correct hash table of D-Bus - * properties for the new collection. You may prefer to use - * secret_collection_create() which does handles this for you. - * - * An @alias is a well-known tag for a collection, such as 'default' (ie: the - * default collection to store items in). This allows other applications to - * easily identify and share a collection. If a collection with the @alias - * already exists, then instead of creating a new collection, the existing - * collection will be returned. If no collection with this alias exists, then - * a new collection will be created and this alias will be assigned to it. - * - * @properties is a set of properties for the new collection. The keys in the - * hash table should be interface.property strings like - * org.freedesktop.Secret.Collection.Label. The values - * in the hash table should be #GVariant values of the properties. - * - * This method may block indefinitely and should not be used in user interface - * threads. The secret service may prompt the user. secret_service_prompt() - * will be used to handle any prompts that are required. - * - * Params: - * properties = hash table of D-Bus properties - * for the new collection - * alias_ = an alias to check for before creating the new - * collection, or to assign to the new collection - * flags = not currently used - * cancellable = optional cancellation object - * - * Return: a new string containing the D-Bus object path - * of the collection - * - * Throws: GException on failure. - */ - public string createCollectionDbusPathSync(HashTable properties, string alias_, SecretCollectionCreateFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto retStr = secret_service_create_collection_dbus_path_sync(secretService, (properties is null) ? null : properties.getHashTableStruct(), Str.toStringz(alias_), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Create a new item in a secret service collection and return its D-Bus - * object path. - * - * It is often easier to use secret_password_store() or secret_item_create() - * rather than using this function. Using this method requires that you setup - * a correct hash table of D-Bus @properties for the new collection. - * - * If the @flags contains %SECRET_ITEM_CREATE_REPLACE, then the secret - * service will search for an item matching the @attributes, and update that item - * instead of creating a new one. - * - * @properties is a set of properties for the new collection. The keys in the - * hash table should be interface.property strings like - * org.freedesktop.Secret.Item.Label. The values - * in the hash table should be #GVariant values of the properties. - * - * This method will return immediately and complete asynchronously. The secret - * service may prompt the user. secret_service_prompt() will be used to handle - * any prompts that are required. - * - * Params: - * collectionPath = the D-Bus object path of the collection in which to create item - * properties = hash table of D-Bus properties - * for the new collection - * value = the secret value to store in the item - * flags = flags for the creation of the new item - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void createItemDbusPath(string collectionPath, HashTable properties, Value value, SecretItemCreateFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_create_item_dbus_path(secretService, Str.toStringz(collectionPath), (properties is null) ? null : properties.getHashTableStruct(), (value is null) ? null : value.getValueStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish asynchronous operation to create a new item in the secret - * service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: a new string containing the D-Bus object path - * of the item - * - * Throws: GException on failure. - */ - public string createItemDbusPathFinish(AsyncResultIF result) - { - GError* err = null; - - auto retStr = secret_service_create_item_dbus_path_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Create a new item in a secret service collection and return its D-Bus - * object path. - * - * It is often easier to use secret_password_store_sync() or secret_item_create_sync() - * rather than using this function. Using this method requires that you setup - * a correct hash table of D-Bus @properties for the new collection. - * - * If the @flags contains %SECRET_ITEM_CREATE_REPLACE, then the secret - * service will search for an item matching the @attributes, and update that item - * instead of creating a new one. - * - * @properties is a set of properties for the new collection. The keys in the - * hash table should be interface.property strings like - * org.freedesktop.Secret.Item.Label. The values - * in the hash table should be #GVariant values of the properties. - * - * This method may block indefinitely and should not be used in user interface - * threads. The secret service may prompt the user. secret_service_prompt() - * will be used to handle any prompts that are required. - * - * Params: - * collectionPath = the D-Bus path of the collection in which to create item - * properties = hash table of D-Bus properties - * for the new collection - * value = the secret value to store in the item - * flags = flags for the creation of the new item - * cancellable = optional cancellation object - * - * Return: a new string containing the D-Bus object path - * of the item - * - * Throws: GException on failure. - */ - public string createItemDbusPathSync(string collectionPath, HashTable properties, Value value, SecretItemCreateFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto retStr = secret_service_create_item_dbus_path_sync(secretService, Str.toStringz(collectionPath), (properties is null) ? null : properties.getHashTableStruct(), (value is null) ? null : value.getValueStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Decode a #SecretValue into GVariant received with the Secret Service - * DBus API. - * - * The GVariant should have a (oayays) signature. - * - * A session must have already been established by the #SecretService, and - * the encoded secret must be valid for that session. - * - * Params: - * value = the encoded secret - * - * Return: the decoded secret value - */ - public Value decodeDbusSecret(Variant value) - { - auto p = secret_service_decode_dbus_secret(secretService, (value is null) ? null : value.getVariantStruct()); - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Value)(cast(SecretValue*) p, true); - } - - /** - * Delete a secret item from the secret service. - * - * The item is represented by its D-Bus object path. If you already have a - * #SecretItem proxy objects, use use secret_item_delete() instead. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * itemPath = the D-Bus path of item to delete - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void deleteItemDbusPath(string itemPath, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_delete_item_dbus_path(secretService, Str.toStringz(itemPath), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete an asynchronous operation to delete a secret item from the secret - * service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: whether the deletion was successful or not - * - * Throws: GException on failure. - */ - public bool deleteItemDbusPathFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_delete_item_dbus_path_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Delete a secret item from the secret service. - * - * The item is represented by its D-Bus object path. If you already have a - * #SecretItem proxy objects, use use secret_item_delete_sync() instead. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * itemPath = the D-Bus path of item to delete - * cancellable = optional cancellation object - * - * Return: whether the deletion was successful or not - * - * Throws: GException on failure. - */ - public bool deleteItemDbusPathSync(string itemPath, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_delete_item_dbus_path_sync(secretService, Str.toStringz(itemPath), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Encodes a #SecretValue into GVariant for use with the Secret Service - * DBus API. - * - * The resulting GVariant will have a (oayays) signature. - * - * A session must have already been established by the #SecretService. - * - * Params: - * value = the secret value - * - * Return: the encoded secret - */ - public Variant encodeDbusSecret(Value value) - { - auto p = secret_service_encode_dbus_secret(secretService, (value is null) ? null : value.getValueStruct()); - - if(p is null) - { - return null; - } - - return new Variant(cast(GVariant*) p); - } - - /** - * Ensure that the #SecretService proxy has established a session with the - * Secret Service. This session is used to transfer secrets. - * - * It is not normally necessary to call this method, as the session is - * established as necessary. You can also pass the %SECRET_SERVICE_OPEN_SESSION - * to secret_service_get() in order to ensure that a session has been established - * by the time you get the #SecretService proxy. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void ensureSession(Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_ensure_session(secretService, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish an asynchronous operation to ensure that the #SecretService proxy - * has established a session with the Secret Service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: whether a session is established or not - * - * Throws: GException on failure. - */ - public bool ensureSessionFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_ensure_session_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Ensure that the #SecretService proxy has established a session with the - * Secret Service. This session is used to transfer secrets. - * - * It is not normally necessary to call this method, as the session is - * established as necessary. You can also pass the %SECRET_SERVICE_OPEN_SESSION - * to secret_service_get_sync() in order to ensure that a session has been - * established by the time you get the #SecretService proxy. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * cancellable = optional cancellation object - * - * Return: whether a session is established or not - * - * Throws: GException on failure. - */ - public bool ensureSessionSync(Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_ensure_session_sync(secretService, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Get the GObject type for collections instantiated by this service. - * This will always be either #SecretCollection or derived from it. - * - * Return: the gobject type for collections - */ - public GType getCollectionGtype() - { - return secret_service_get_collection_gtype(secretService); - } - - /** - * Get a list of #SecretCollection objects representing all the collections - * in the secret service. - * - * If the %SECRET_SERVICE_LOAD_COLLECTIONS flag was not specified when - * initializing #SecretService proxy object, then this method will return - * %NULL. Use secret_service_load_collections() to load the collections. - * - * Return: a - * list of the collections in the secret service - */ - public ListG getCollections() - { - auto p = secret_service_get_collections(secretService); - - if(p is null) - { - return null; - } - - return new ListG(cast(GList*) p, true); - } - - /** - * Get the GObject type for items instantiated by this service. - * This will always be either #SecretItem or derived from it. - * - * Return: the gobject type for items - */ - public GType getItemGtype() - { - return secret_service_get_item_gtype(secretService); - } - - /** - * Get the secret value for an secret item stored in the service. - * - * The item is represented by its D-Bus object path. If you already have a - * #SecretItem proxy object, use use secret_item_get_secret() to more simply - * get its secret value. - * - * This function returns immediately and completes asynchronously. - * - * Params: - * itemPath = the D-Bus path to item to retrieve secret for - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void getSecretForDbusPath(string itemPath, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_get_secret_for_dbus_path(secretService, Str.toStringz(itemPath), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to get the secret value for an - * secret item stored in the service. - * - * Will return %NULL if the item is locked. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: the newly allocated secret value - * for the item, which should be released with secret_value_unref() - * - * Throws: GException on failure. - */ - public Value getSecretForDbusPathFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_get_secret_for_dbus_path_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Value)(cast(SecretValue*) p, true); - } - - /** - * Get the secret value for an secret item stored in the service. - * - * The item is represented by its D-Bus object path. If you already have a - * #SecretItem proxy object, use use secret_item_load_secret_sync() to more simply - * get its secret value. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Will return %NULL if the item is locked. - * - * Params: - * itemPath = the D-Bus path to item to retrieve secret for - * cancellable = optional cancellation object - * - * Return: the newly allocated secret value - * for the item, which should be released with secret_value_unref() - * - * Throws: GException on failure. - */ - public Value getSecretForDbusPathSync(string itemPath, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_get_secret_for_dbus_path_sync(secretService, Str.toStringz(itemPath), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Value)(cast(SecretValue*) p, true); - } - - /** - * Get the secret values for an secret items stored in the service. - * - * The items are represented by their D-Bus object paths. If you already have - * #SecretItem proxy objects, use use secret_item_load_secrets() to more simply - * get their secret values. - * - * This function returns immediately and completes asynchronously. - * - * Params: - * itemPaths = the D-Bus paths to items to retrieve secrets for - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void getSecretsForDbusPaths(string[] itemPaths, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_get_secrets_for_dbus_paths(secretService, Str.toStringzArray(itemPaths), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to get the secret values for an - * secret items stored in the service. - * - * Items that are locked will not be included the results. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: a newly - * allocated hash table of item_path keys to #SecretValue - * values. - * - * Throws: GException on failure. - */ - public HashTable getSecretsForDbusPathsFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_get_secrets_for_dbus_paths_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new HashTable(cast(GHashTable*) p, true); - } - - /** - * Get the secret values for an secret items stored in the service. - * - * The items are represented by their D-Bus object paths. If you already have - * #SecretItem proxy objects, use use secret_item_load_secrets_sync() to more - * simply get their secret values. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Items that are locked will not be included the results. - * - * Params: - * itemPaths = the D-Bus paths to items to retrieve secrets for - * cancellable = optional cancellation object - * - * Return: a newly - * allocated hash table of item_path keys to #SecretValue - * values. - * - * Throws: GException on failure. - */ - public HashTable getSecretsForDbusPathsSync(string[] itemPaths, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_get_secrets_for_dbus_paths_sync(secretService, Str.toStringzArray(itemPaths), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new HashTable(cast(GHashTable*) p, true); - } - - /** - * Get the set of algorithms being used to transfer secrets between this - * secret service proxy and the Secret Service itself. - * - * This will be %NULL if no session has been established. Use - * secret_service_ensure_session() to establish a session. - * - * Return: a string representing the algorithms for transferring - * secrets - */ - public string getSessionAlgorithms() - { - return Str.toString(secret_service_get_session_algorithms(secretService)); - } - - /** - * Get the D-Bus object path of the session object being used to transfer - * secrets between this secret service proxy and the Secret Service itself. - * - * This will be %NULL if no session has been established. Use - * secret_service_ensure_session() to establish a session. - * - * Return: a string representing the D-Bus object path of the - * session - */ - public string getSessionDbusPath() - { - return Str.toString(secret_service_get_session_dbus_path(secretService)); - } - - /** - * Ensure that the #SecretService proxy has loaded all the collections present - * in the Secret Service. This affects the result of - * secret_service_get_collections(). - * - * You can also pass the %SECRET_SERVICE_LOAD_COLLECTIONS to - * secret_service_get_sync() in order to ensure that the collections have been - * loaded by the time you get the #SecretService proxy. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void loadCollections(Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_load_collections(secretService, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete an asynchronous operation to ensure that the #SecretService proxy - * has loaded all the collections present in the Secret Service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: whether the load was successful or not - * - * Throws: GException on failure. - */ - public bool loadCollectionsFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_load_collections_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Ensure that the #SecretService proxy has loaded all the collections present - * in the Secret Service. This affects the result of - * secret_service_get_collections(). - * - * You can also pass the %SECRET_SERVICE_LOAD_COLLECTIONS to - * secret_service_get_sync() in order to ensure that the collections have been - * loaded by the time you get the #SecretService proxy. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * cancellable = optional cancellation object - * - * Return: whether the load was successful or not - * - * Throws: GException on failure. - */ - public bool loadCollectionsSync(Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_load_collections_sync(secretService, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Lock items or collections in the secret service. - * - * The secret service may not be able to lock items individually, and may - * lock an entire collection instead. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * This method returns immediately and completes asynchronously. The secret - * service may prompt the user. secret_service_prompt() will be used to handle - * any prompts that show up. - * - * Params: - * objects = the items or collections to lock - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void lock(ListG objects, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_lock(secretService, (objects is null) ? null : objects.getListGStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Lock items or collections in the secret service. - * - * The items or collections are represented by their D-Bus object paths. If you - * already have #SecretItem and #SecretCollection proxy objects, use use - * secret_service_lock() instead. - * - * The secret service may not be able to lock items individually, and may - * lock an entire collection instead. - * - * This method returns immediately and completes asynchronously. The secret - * service may prompt the user. secret_service_prompt() will be used to handle - * any prompts that show up. - * - * Params: - * paths = the D-Bus paths for items or collections to lock - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void lockDbusPaths(string[] paths, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_lock_dbus_paths(secretService, Str.toStringzArray(paths), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to lock items or collections in the secret - * service. - * - * The secret service may not be able to lock items individually, and may - * lock an entire collection instead. - * - * Params: - * result = asynchronous result passed to the callback - * locked = location to place array of D-Bus paths of items or collections - * that were locked - * - * Return: the number of items or collections that were locked - * - * Throws: GException on failure. - */ - public int lockDbusPathsFinish(AsyncResultIF result, out string[] locked) - { - char** outlocked = null; - GError* err = null; - - auto p = secret_service_lock_dbus_paths_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &outlocked, &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - locked = Str.toStringArray(outlocked); - - return p; - } - - /** - * Lock items or collections in the secret service. - * - * The items or collections are represented by their D-Bus object paths. If you - * already have #SecretItem and #SecretCollection proxy objects, use use - * secret_service_lock_sync() instead. - * - * The secret service may not be able to lock items individually, and may - * lock an entire collection instead. - * - * This method may block indefinitely and should not be used in user - * interface threads. The secret service may prompt the user. - * secret_service_prompt() will be used to handle any prompts that show up. - * - * Params: - * paths = the D-Bus object paths of the items or collections to lock - * cancellable = optional cancellation object - * locked = location to place array of D-Bus paths of items or collections - * that were locked - * - * Return: the number of items or collections that were locked - * - * Throws: GException on failure. - */ - public int lockDbusPathsSync(string[] paths, Cancellable cancellable, out string[] locked) - { - char** outlocked = null; - GError* err = null; - - auto p = secret_service_lock_dbus_paths_sync(secretService, Str.toStringzArray(paths), (cancellable is null) ? null : cancellable.getCancellableStruct(), &outlocked, &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - locked = Str.toStringArray(outlocked); - - return p; - } - - /** - * Complete asynchronous operation to lock items or collections in the secret - * service. - * - * The secret service may not be able to lock items individually, and may - * lock an entire collection instead. - * - * Params: - * result = asynchronous result passed to the callback - * locked = location to place list of items or collections that were locked - * - * Return: the number of items or collections that were locked - * - * Throws: GException on failure. - */ - public int lockFinish(AsyncResultIF result, out ListG locked) - { - GList* outlocked = null; - GError* err = null; - - auto p = secret_service_lock_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &outlocked, &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - locked = new ListG(outlocked); - - return p; - } - - /** - * Lock items or collections in the secret service. - * - * The secret service may not be able to lock items individually, and may - * lock an entire collection instead. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block indefinitely and should not be used in user - * interface threads. The secret service may prompt the user. - * secret_service_prompt() will be used to handle any prompts that show up. - * - * Params: - * objects = the items or collections to lock - * cancellable = optional cancellation object - * locked = location to place list of items or collections that were locked - * - * Return: the number of items or collections that were locked - * - * Throws: GException on failure. - */ - public int lockSync(ListG objects, Cancellable cancellable, out ListG locked) - { - GList* outlocked = null; - GError* err = null; - - auto p = secret_service_lock_sync(secretService, (objects is null) ? null : objects.getListGStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &outlocked, &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - locked = new ListG(outlocked); - - return p; - } - - /** - * Lookup a secret value in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * schema = the schema for the attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void lookup(Schema schema, HashTable attributes, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_lookup(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish asynchronous operation to lookup a secret value in the secret service. - * - * If no secret is found then %NULL is returned. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: a newly allocated #SecretValue, which should be - * released with secret_value_unref(), or %NULL if no secret found - * - * Throws: GException on failure. - */ - public Value lookupFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_lookup_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Value)(cast(SecretValue*) p, true); - } - - /** - * Lookup a secret value in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * schema = the schema for the attributes - * attributes = the attribute keys and values - * cancellable = optional cancellation object - * - * Return: a newly allocated #SecretValue, which should be - * released with secret_value_unref(), or %NULL if no secret found - * - * Throws: GException on failure. - */ - public Value lookupSync(Schema schema, HashTable attributes, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_lookup_sync(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Value)(cast(SecretValue*) p, true); - } - - /** - * Perform prompting for a #SecretPrompt. - * - * This function is called by other parts of this library to handle prompts - * for the various actions that can require prompting. - * - * Override the #SecretServiceClass prompt_async virtual method - * to change the behavior of the prompting. The default behavior is to simply - * run secret_prompt_perform() on the prompt. - * - * Params: - * prompt = the prompt - * returnType = the variant type of the prompt result - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void prompt(Prompt prompt, VariantType returnType, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_prompt(secretService, (prompt is null) ? null : prompt.getPromptStruct(), (returnType is null) ? null : returnType.getVariantTypeStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Perform prompting for a #SecretPrompt. - * - * This function is called by other parts of this library to handle prompts - * for the various actions that can require prompting. - * - * Override the #SecretServiceClass prompt_async virtual method - * to change the behavior of the propmting. The default behavior is to simply - * run secret_prompt_perform() on the prompt. - * - * Params: - * promptPath = the D-Bus object path of the prompt - * returnType = the variant type of the prompt result - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void promptAtDbusPath(string promptPath, VariantType returnType, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_prompt_at_dbus_path(secretService, Str.toStringz(promptPath), (returnType is null) ? null : returnType.getVariantTypeStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to perform prompting for a #SecretPrompt. - * - * Returns a variant result if the prompt was completed and not dismissed. The - * type of result depends on the action the prompt is completing, and is defined - * in the Secret Service DBus API specification. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: %NULL if the prompt was dismissed or an error occurred, - * a variant result if the prompt was successful - * - * Throws: GException on failure. - */ - public Variant promptAtDbusPathFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_prompt_at_dbus_path_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new Variant(cast(GVariant*) p, true); - } - - /** - * Perform prompting for a #SecretPrompt. - * - * Override the #SecretServiceClass prompt_async virtual method - * to change the behavior of the propmting. The default behavior is to simply - * run secret_prompt_perform() on the prompt. - * - * Returns a variant result if the prompt was completed and not dismissed. The - * type of result depends on the action the prompt is completing, and is defined - * in the Secret Service DBus API specification. - * - * This method may block and should not be used in user interface threads. - * - * Params: - * promptPath = the D-Bus object path of the prompt - * cancellable = optional cancellation object - * returnType = the variant type of the prompt result - * - * Return: %NULL if the prompt was dismissed or an error occurred, - * a variant result if the prompt was successful - * - * Throws: GException on failure. - */ - public Variant promptAtDbusPathSync(string promptPath, Cancellable cancellable, VariantType returnType) - { - GError* err = null; - - auto p = secret_service_prompt_at_dbus_path_sync(secretService, Str.toStringz(promptPath), (cancellable is null) ? null : cancellable.getCancellableStruct(), (returnType is null) ? null : returnType.getVariantTypeStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new Variant(cast(GVariant*) p, true); - } - - /** - * Complete asynchronous operation to perform prompting for a #SecretPrompt. - * - * Returns a variant result if the prompt was completed and not dismissed. The - * type of result depends on the action the prompt is completing, and is defined - * in the Secret Service DBus API specification. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: %NULL if the prompt was dismissed or an error occurred, - * a variant result if the prompt was successful - * - * Throws: GException on failure. - */ - public Variant promptFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_prompt_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new Variant(cast(GVariant*) p, true); - } - - /** - * Perform prompting for a #SecretPrompt. - * - * Runs a prompt and performs the prompting. Returns a variant result if the - * prompt was completed and not dismissed. The type of result depends on the - * action the prompt is completing, and is defined in the Secret Service DBus - * API specification. - * - * This function is called by other parts of this library to handle prompts - * for the various actions that can require prompting. - * - * Override the #SecretServiceClass prompt_sync virtual method - * to change the behavior of the prompting. The default behavior is to simply - * run secret_prompt_perform_sync() on the prompt with a %NULL window_id. - * - * Params: - * prompt = the prompt - * cancellable = optional cancellation object - * returnType = the variant type of the prompt result - * - * Return: %NULL if the prompt was dismissed or an error occurred, - * a variant result if the prompt was successful - * - * Throws: GException on failure. - */ - public Variant promptSync(Prompt prompt, Cancellable cancellable, VariantType returnType) - { - GError* err = null; - - auto p = secret_service_prompt_sync(secretService, (prompt is null) ? null : prompt.getPromptStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), (returnType is null) ? null : returnType.getVariantTypeStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new Variant(cast(GVariant*) p, true); - } - - /** - * Lookup which collection is assigned to this alias. Aliases help determine - * well known collections, such as 'default'. This method looks up the - * dbus object path of the well known collection. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * alias_ = the alias to lookup - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void readAliasDbusPath(string alias_, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_read_alias_dbus_path(secretService, Str.toStringz(alias_), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish an asynchronous operation to lookup which collection is assigned - * to an alias. This method returns the DBus object path of the collection - * - * Params: - * result = asynchronous result passed to callback - * - * Return: the collection dbus object path, or %NULL if - * none assigned to the alias - * - * Throws: GException on failure. - */ - public string readAliasDbusPathFinish(AsyncResultIF result) - { - GError* err = null; - - auto retStr = secret_service_read_alias_dbus_path_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Lookup which collection is assigned to this alias. Aliases help determine - * well known collections, such as 'default'. This method returns the dbus - * object path of the collection. - * - * This method may block and should not be used in user interface threads. - * - * Params: - * alias_ = the alias to lookup - * cancellable = optional cancellation object - * - * Return: the collection dbus object path, or %NULL if - * none assigned to the alias - * - * Throws: GException on failure. - */ - public string readAliasDbusPathSync(string alias_, Cancellable cancellable) - { - GError* err = null; - - auto retStr = secret_service_read_alias_dbus_path_sync(secretService, Str.toStringz(alias_), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - scope(exit) Str.freeString(retStr); - return Str.toString(retStr); - } - - /** - * Search for items matching the @attributes. All collections are searched. - * The @attributes should be a table of string keys and string values. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * If %SECRET_SEARCH_ALL is set in @flags, then all the items matching the - * search will be returned. Otherwise only the first item will be returned. - * This is almost always the unlocked item that was most recently stored. - * - * If %SECRET_SEARCH_UNLOCK is set in @flags, then items will be unlocked - * if necessary. In either case, locked and unlocked items will match the - * search and be returned. If the unlock fails, the search does not fail. - * - * If %SECRET_SEARCH_LOAD_SECRETS is set in @flags, then the items will have - * their secret values loaded and available via secret_item_get_secret(). - * - * This function returns immediately and completes asynchronously. - * - * Params: - * schema = the schema for the attributes - * attributes = search for items matching these attributes - * flags = search option flags - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void search(Schema schema, HashTable attributes, SecretSearchFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_search(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to search for items. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: a list of items that matched the search - * - * Throws: GException on failure. - */ - public ListG searchFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_search_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new ListG(cast(GList*) p, true); - } - - /** - * Search for items matching the @attributes, and return their D-Bus object paths. - * All collections are searched. The @attributes should be a table of string keys - * and string values. - * - * This function returns immediately and completes asynchronously. - * - * When your callback is called use secret_service_search_for_dbus_paths_finish() - * to get the results of this function. Only the D-Bus object paths of the - * items will be returned. If you would like #SecretItem objects to be returned - * instead, then use the secret_service_search() function. - * - * Params: - * schema = the schema for the attributes - * attributes = search for items matching these attributes - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void searchForDbusPaths(Schema schema, HashTable attributes, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_search_for_dbus_paths(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to search for items, and return their - * D-Bus object paths. - * - * Matching items that are locked or unlocked, have their D-Bus paths placed - * in the @locked or @unlocked arrays respectively. - * - * D-Bus object paths of the items will be returned in the @unlocked or - * @locked arrays. If you would to have #SecretItem objects to be returned - * instead, then us the secret_service_search() and - * secret_service_search_finish() functions. - * - * Params: - * result = asynchronous result passed to callback - * unlocked = location to place an array of D-Bus object paths for matching - * items which were locked. - * locked = location to place an array of D-Bus object paths for matching - * items which were locked. - * - * Return: whether the search was successful or not - * - * Throws: GException on failure. - */ - public bool searchForDbusPathsFinish(AsyncResultIF result, out string[] unlocked, out string[] locked) - { - char** outunlocked = null; - char** outlocked = null; - GError* err = null; - - auto p = secret_service_search_for_dbus_paths_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &outunlocked, &outlocked, &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - unlocked = Str.toStringArray(outunlocked); - locked = Str.toStringArray(outlocked); - - return p; - } - - /** - * Search for items matching the @attributes, and return their D-Bus object - * paths. All collections are searched. The @attributes should be a table of - * string keys and string values. - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * Matching items that are locked or unlocked, have their D-Bus paths placed - * in the @locked or @unlocked arrays respectively. - * - * D-Bus object paths of the items will be returned in the @unlocked or - * @locked arrays. If you would to have #SecretItem objects to be returned - * instead, then use the secret_service_search_sync() function. - * - * Params: - * schema = the schema for the attributes - * attributes = search for items matching these attributes - * cancellable = optional cancellation object - * unlocked = location to place an array of D-Bus object paths for matching - * items which were locked. - * locked = location to place an array of D-Bus object paths for matching - * items which were locked. - * - * Return: whether the search was successful or not - * - * Throws: GException on failure. - */ - public bool searchForDbusPathsSync(Schema schema, HashTable attributes, Cancellable cancellable, out string[] unlocked, out string[] locked) - { - char** outunlocked = null; - char** outlocked = null; - GError* err = null; - - auto p = secret_service_search_for_dbus_paths_sync(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &outunlocked, &outlocked, &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - unlocked = Str.toStringArray(outunlocked); - locked = Str.toStringArray(outlocked); - - return p; - } - - /** - * Search for items matching the @attributes. All collections are searched. - * The @attributes should be a table of string keys and string values. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * If %SECRET_SEARCH_ALL is set in @flags, then all the items matching the - * search will be returned. Otherwise only the first item will be returned. - * This is almost always the unlocked item that was most recently stored. - * - * If %SECRET_SEARCH_UNLOCK is set in @flags, then items will be unlocked - * if necessary. In either case, locked and unlocked items will match the - * search and be returned. If the unlock fails, the search does not fail. - * - * If %SECRET_SEARCH_LOAD_SECRETS is set in @flags, then the items' secret - * values will be loaded for any unlocked items. Loaded item secret values - * are available via secret_item_get_secret(). If the load of a secret values - * fail, then the - * - * This function may block indefinetely. Use the asynchronous version - * in user interface threads. - * - * Params: - * schema = the schema for the attributes - * attributes = search for items matching these attributes - * flags = search option flags - * cancellable = optional cancellation object - * - * Return: a list of items that matched the search - * - * Throws: GException on failure. - */ - public ListG searchSync(Schema schema, HashTable attributes, SecretSearchFlags flags, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_search_sync(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - if(p is null) - { - return null; - } - - return new ListG(cast(GList*) p, true); - } - - /** - * Assign a collection to this alias. Aliases help determine - * well known collections, such as 'default'. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * alias_ = the alias to assign the collection to - * collection = the collection to assign to the alias - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void setAlias(string alias_, Collection collection, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_set_alias(secretService, Str.toStringz(alias_), (collection is null) ? null : collection.getCollectionStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish an asynchronous operation to assign a collection to an alias. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: %TRUE if successful - * - * Throws: GException on failure. - */ - public bool setAliasFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_set_alias_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Assign a collection to this alias. Aliases help determine - * well known collections, such as 'default'. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block and should not be used in user interface threads. - * - * Params: - * alias_ = the alias to assign the collection to - * collection = the collection to assign to the alias - * cancellable = optional cancellation object - * - * Return: %TRUE if successful - * - * Throws: GException on failure. - */ - public bool setAliasSync(string alias_, Collection collection, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_set_alias_sync(secretService, Str.toStringz(alias_), (collection is null) ? null : collection.getCollectionStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Assign a collection to this alias. Aliases help determine - * well known collections, such as 'default'. This method takes the dbus object - * path of the collection to assign to the alias. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * alias_ = the alias to assign the collection to - * collectionPath = the dbus object path of the collection to assign to the alias - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void setAliasToDbusPath(string alias_, string collectionPath, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_set_alias_to_dbus_path(secretService, Str.toStringz(alias_), Str.toStringz(collectionPath), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish an asynchronous operation to assign a collection to an alias. - * - * Params: - * result = asynchronous result passed to callback - * - * Return: %TRUE if successful - * - * Throws: GException on failure. - */ - public bool setAliasToDbusPathFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_set_alias_to_dbus_path_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Assign a collection to this alias. Aliases help determine - * well known collections, such as 'default'. This method takes the dbus object - * path of the collection to assign to the alias. - * - * This method may block and should not be used in user interface threads. - * - * Params: - * alias_ = the alias to assign the collection to - * collectionPath = the dbus object path of the collection to assign to the alias - * cancellable = optional cancellation object - * - * Return: %TRUE if successful - * - * Throws: GException on failure. - */ - public bool setAliasToDbusPathSync(string alias_, string collectionPath, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_set_alias_to_dbus_path_sync(secretService, Str.toStringz(alias_), Str.toStringz(collectionPath), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Store a secret value in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If the attributes match a secret item already stored in the collection, then - * the item will be updated with these new values. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * If @collection is not specified, then the default collection will be - * used. Use #SECRET_COLLECTION_SESSION to store the password in the session - * collection, which doesn't get stored across login sessions. - * - * This method will return immediately and complete asynchronously. - * - * Params: - * schema = the schema to use to check attributes - * attributes = the attribute keys and values - * collection = a collection alias, or D-Bus object path of the collection where to store the secret - * label = label for the secret - * value = the secret value - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to be passed to the callback - */ - public void store(Schema schema, HashTable attributes, string collection, string label, Value value, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_store(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), Str.toStringz(collection), Str.toStringz(label), (value is null) ? null : value.getValueStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Finish asynchronous operation to store a secret value in the secret service. - * - * Params: - * result = the asynchronous result passed to the callback - * - * Return: whether the storage was successful or not - * - * Throws: GException on failure. - */ - public bool storeFinish(AsyncResultIF result) - { - GError* err = null; - - auto p = secret_service_store_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Store a secret value in the secret service. - * - * The @attributes should be a set of key and value string pairs. - * - * If the attributes match a secret item already stored in the collection, then - * the item will be updated with these new values. - * - * If @collection is %NULL, then the default collection will be - * used. Use #SECRET_COLLECTION_SESSION to store the password in the session - * collection, which doesn't get stored across login sessions. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block indefinitely and should not be used in user interface - * threads. - * - * Params: - * schema = the schema for the attributes - * attributes = the attribute keys and values - * collection = a collection alias, or D-Bus object path of the collection where to store the secret - * label = label for the secret - * value = the secret value - * cancellable = optional cancellation object - * - * Return: whether the storage was successful or not - * - * Throws: GException on failure. - */ - public bool storeSync(Schema schema, HashTable attributes, string collection, string label, Value value, Cancellable cancellable) - { - GError* err = null; - - auto p = secret_service_store_sync(secretService, (schema is null) ? null : schema.getSchemaStruct(), (attributes is null) ? null : attributes.getHashTableStruct(), Str.toStringz(collection), Str.toStringz(label), (value is null) ? null : value.getValueStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0; - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - return p; - } - - /** - * Unlock items or collections in the secret service. - * - * The secret service may not be able to unlock items individually, and may - * unlock an entire collection instead. - * - * If @service is NULL, then secret_service_get() will be called to get - * the default #SecretService proxy. - * - * This method may block indefinitely and should not be used in user - * interface threads. The secret service may prompt the user. - * secret_service_prompt() will be used to handle any prompts that show up. - * - * Params: - * objects = the items or collections to unlock - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void unlock(ListG objects, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_unlock(secretService, (objects is null) ? null : objects.getListGStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Unlock items or collections in the secret service. - * - * The items or collections are represented by their D-Bus object paths. If you - * already have #SecretItem and #SecretCollection proxy objects, use use - * secret_service_unlock() instead. - * - * The secret service may not be able to unlock items individually, and may - * unlock an entire collection instead. - * - * This method returns immediately and completes asynchronously. The secret - * service may prompt the user. secret_service_prompt() will be used to handle - * any prompts that show up. - * - * Params: - * paths = the D-Bus paths for items or collections to unlock - * cancellable = optional cancellation object - * callback = called when the operation completes - * userData = data to pass to the callback - */ - public void unlockDbusPaths(string[] paths, Cancellable cancellable, GAsyncReadyCallback callback, void* userData) - { - secret_service_unlock_dbus_paths(secretService, Str.toStringzArray(paths), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData); - } - - /** - * Complete asynchronous operation to unlock items or collections in the secret - * service. - * - * The secret service may not be able to unlock items individually, and may - * unlock an entire collection instead. - * - * Params: - * result = asynchronous result passed to the callback - * unlocked = location to place array of D-Bus paths of items or collections - * that were unlocked - * - * Return: the number of items or collections that were unlocked - * - * Throws: GException on failure. - */ - public int unlockDbusPathsFinish(AsyncResultIF result, out string[] unlocked) - { - char** outunlocked = null; - GError* err = null; - - auto p = secret_service_unlock_dbus_paths_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &outunlocked, &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - unlocked = Str.toStringArray(outunlocked); - - return p; - } - - /** - * Unlock items or collections in the secret service. - * - * The items or collections are represented by their D-Bus object paths. If you - * already have #SecretItem and #SecretCollection proxy objects, use use - * secret_service_unlock_sync() instead. - * - * The secret service may not be able to unlock items individually, and may - * unlock an entire collection instead. - * - * This method may block indefinitely and should not be used in user - * interface threads. The secret service may prompt the user. - * secret_service_prompt() will be used to handle any prompts that show up. - * - * Params: - * paths = the D-Bus object paths of the items or collections to unlock - * cancellable = optional cancellation object - * unlocked = location to place array of D-Bus paths of items or collections - * that were unlocked - * - * Return: the number of items or collections that were unlocked - * - * Throws: GException on failure. - */ - public int unlockDbusPathsSync(string[] paths, Cancellable cancellable, out string[] unlocked) - { - char** outunlocked = null; - GError* err = null; - - auto p = secret_service_unlock_dbus_paths_sync(secretService, Str.toStringzArray(paths), (cancellable is null) ? null : cancellable.getCancellableStruct(), &outunlocked, &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - unlocked = Str.toStringArray(outunlocked); - - return p; - } - - /** - * Complete asynchronous operation to unlock items or collections in the secret - * service. - * - * The secret service may not be able to unlock items individually, and may - * unlock an entire collection instead. - * - * Params: - * result = asynchronous result passed to the callback - * unlocked = location to place list of items or collections that were unlocked - * - * Return: the number of items or collections that were unlocked - * - * Throws: GException on failure. - */ - public int unlockFinish(AsyncResultIF result, out ListG unlocked) - { - GList* outunlocked = null; - GError* err = null; - - auto p = secret_service_unlock_finish(secretService, (result is null) ? null : result.getAsyncResultStruct(), &outunlocked, &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - unlocked = new ListG(outunlocked); - - return p; - } - - /** - * Unlock items or collections in the secret service. - * - * The secret service may not be able to unlock items individually, and may - * unlock an entire collection instead. - * - * If @service is NULL, then secret_service_get_sync() will be called to get - * the default #SecretService proxy. - * - * This method may block indefinitely and should not be used in user - * interface threads. The secret service may prompt the user. - * secret_service_prompt() will be used to handle any prompts that show up. - * - * Params: - * objects = the items or collections to unlock - * cancellable = optional cancellation object - * unlocked = location to place list of items or collections that were unlocked - * - * Return: the number of items or collections that were unlocked - * - * Throws: GException on failure. - */ - public int unlockSync(ListG objects, Cancellable cancellable, out ListG unlocked) - { - GList* outunlocked = null; - GError* err = null; - - auto p = secret_service_unlock_sync(secretService, (objects is null) ? null : objects.getListGStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &outunlocked, &err); - - if (err !is null) - { - throw new GException( new ErrorG(err) ); - } - - unlocked = new ListG(outunlocked); - - return p; - } -} diff --git a/source/secret/Value.d b/source/secret/Value.d deleted file mode 100644 index 605033694..000000000 --- a/source/secret/Value.d +++ /dev/null @@ -1,190 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secret.Value; - -private import glib.ConstructionException; -private import glib.Str; -private import gobject.ObjectG; -private import secretc.secret; -public import secretc.secrettypes; - - -/** - * A secret value, like a password or other binary secret. - */ -public class Value -{ - /** the main Gtk struct */ - protected SecretValue* secretValue; - protected bool ownedRef; - - /** Get the main Gtk struct */ - public SecretValue* getValueStruct() - { - return secretValue; - } - - /** the main Gtk struct as a void* */ - protected void* getStruct() - { - return cast(void*)secretValue; - } - - /** - * Sets our main struct and passes it to the parent class. - */ - public this (SecretValue* secretValue, bool ownedRef = false) - { - this.secretValue = secretValue; - this.ownedRef = ownedRef; - } - - - /** */ - public static GType getType() - { - return secret_value_get_type(); - } - - /** - * Create a #SecretValue for the secret data passed in. The secret data is - * copied into non-pageable 'secure' memory. - * - * If the length is less than zero, then @secret is assumed to be - * null-terminated. - * - * Params: - * secret = the secret data - * length = the length of the data - * contentType = the content type of the data - * - * Return: the new #SecretValue - * - * Throws: ConstructionException GTK+ fails to create the object. - */ - public this(string secret, ptrdiff_t length, string contentType) - { - auto p = secret_value_new(Str.toStringz(secret), length, Str.toStringz(contentType)); - - if(p is null) - { - throw new ConstructionException("null returned by new"); - } - - this(cast(SecretValue*) p); - } - - /** - * Create a #SecretValue for the secret data passed in. The secret data is - * not copied, and will later be freed with the @destroy function. - * - * If the length is less than zero, then @secret is assumed to be - * null-terminated. - * - * Params: - * secret = the secret data - * length = the length of the data - * contentType = the content type of the data - * destroy = function to call to free the secret data - * - * Return: the new #SecretValue - * - * Throws: ConstructionException GTK+ fails to create the object. - */ - public this(string secret, ptrdiff_t length, string contentType, GDestroyNotify destroy) - { - auto p = secret_value_new_full(Str.toStringz(secret), length, Str.toStringz(contentType), destroy); - - if(p is null) - { - throw new ConstructionException("null returned by new_full"); - } - - this(cast(SecretValue*) p); - } - - /** - * Get the secret data in the #SecretValue. The value is not necessarily - * null-terminated unless it was created with secret_value_new() or a - * null-terminated string was passed to secret_value_new_full(). - * - * Return: the secret data - */ - public string get() - { - size_t length; - - return Str.toString(secret_value_get(secretValue, &length)); - } - - /** - * Get the content type of the secret value, such as - * text/plain. - * - * Return: the content type - */ - public string getContentType() - { - return Str.toString(secret_value_get_content_type(secretValue)); - } - - /** - * Get the secret data in the #SecretValue if it contains a textual - * value. The content type must be text/plain. - * - * Return: the content type - */ - public string getText() - { - return Str.toString(secret_value_get_text(secretValue)); - } - - /** - * Add another reference to the #SecretValue. For each reference - * secret_value_unref() should be called to unreference the value. - * - * Return: the value - */ - public Value doref() - { - auto p = secret_value_ref(secretValue); - - if(p is null) - { - return null; - } - - return ObjectG.getDObject!(Value)(cast(SecretValue*) p, true); - } - - /** - * Unreference a #SecretValue. When the last reference is gone, then - * the value will be freed. - */ - public void unref() - { - secret_value_unref(secretValue); - } -} diff --git a/source/secretc/secret.d b/source/secretc/secret.d deleted file mode 100644 index f299acc38..000000000 --- a/source/secretc/secret.d +++ /dev/null @@ -1,679 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secretc.secret; - -import std.stdio; - -import secretc.secrettypes; -import gtkc.Loader; -import gtkc.paths; - -enum LIBRARY_SECRET = "libsecret-1.so.0"; - -shared static this() -{ - - try { - Linker.loadLibrary(LIBRARY_SECRET); - } catch (Exception e) { - stderr.writeln("Library " ~ LIBRARY_SECRET ~ " cannot be loaded, related functionality will not be available"); - return; - } - - // secret.Collection - - Linker.link(secret_collection_get_type, "secret_collection_get_type", LIBRARY_SECRET); - Linker.link(secret_collection_new_for_dbus_path_finish, "secret_collection_new_for_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_collection_new_for_dbus_path_sync, "secret_collection_new_for_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_collection_create, "secret_collection_create", LIBRARY_SECRET); - Linker.link(secret_collection_create_finish, "secret_collection_create_finish", LIBRARY_SECRET); - Linker.link(secret_collection_create_sync, "secret_collection_create_sync", LIBRARY_SECRET); - Linker.link(secret_collection_for_alias, "secret_collection_for_alias", LIBRARY_SECRET); - Linker.link(secret_collection_for_alias_finish, "secret_collection_for_alias_finish", LIBRARY_SECRET); - Linker.link(secret_collection_for_alias_sync, "secret_collection_for_alias_sync", LIBRARY_SECRET); - Linker.link(secret_collection_new_for_dbus_path, "secret_collection_new_for_dbus_path", LIBRARY_SECRET); - Linker.link(secret_collection_delete, "secret_collection_delete", LIBRARY_SECRET); - Linker.link(secret_collection_delete_finish, "secret_collection_delete_finish", LIBRARY_SECRET); - Linker.link(secret_collection_delete_sync, "secret_collection_delete_sync", LIBRARY_SECRET); - Linker.link(secret_collection_get_created, "secret_collection_get_created", LIBRARY_SECRET); - Linker.link(secret_collection_get_flags, "secret_collection_get_flags", LIBRARY_SECRET); - Linker.link(secret_collection_get_items, "secret_collection_get_items", LIBRARY_SECRET); - Linker.link(secret_collection_get_label, "secret_collection_get_label", LIBRARY_SECRET); - Linker.link(secret_collection_get_locked, "secret_collection_get_locked", LIBRARY_SECRET); - Linker.link(secret_collection_get_modified, "secret_collection_get_modified", LIBRARY_SECRET); - Linker.link(secret_collection_get_service, "secret_collection_get_service", LIBRARY_SECRET); - Linker.link(secret_collection_load_items, "secret_collection_load_items", LIBRARY_SECRET); - Linker.link(secret_collection_load_items_finish, "secret_collection_load_items_finish", LIBRARY_SECRET); - Linker.link(secret_collection_load_items_sync, "secret_collection_load_items_sync", LIBRARY_SECRET); - Linker.link(secret_collection_refresh, "secret_collection_refresh", LIBRARY_SECRET); - Linker.link(secret_collection_search, "secret_collection_search", LIBRARY_SECRET); - Linker.link(secret_collection_search_finish, "secret_collection_search_finish", LIBRARY_SECRET); - Linker.link(secret_collection_search_for_dbus_paths, "secret_collection_search_for_dbus_paths", LIBRARY_SECRET); - Linker.link(secret_collection_search_for_dbus_paths_finish, "secret_collection_search_for_dbus_paths_finish", LIBRARY_SECRET); - Linker.link(secret_collection_search_for_dbus_paths_sync, "secret_collection_search_for_dbus_paths_sync", LIBRARY_SECRET); - Linker.link(secret_collection_search_sync, "secret_collection_search_sync", LIBRARY_SECRET); - Linker.link(secret_collection_set_label, "secret_collection_set_label", LIBRARY_SECRET); - Linker.link(secret_collection_set_label_finish, "secret_collection_set_label_finish", LIBRARY_SECRET); - Linker.link(secret_collection_set_label_sync, "secret_collection_set_label_sync", LIBRARY_SECRET); - - // secret.Item - - Linker.link(secret_item_get_type, "secret_item_get_type", LIBRARY_SECRET); - Linker.link(secret_item_new_for_dbus_path_finish, "secret_item_new_for_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_item_new_for_dbus_path_sync, "secret_item_new_for_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_item_create, "secret_item_create", LIBRARY_SECRET); - Linker.link(secret_item_create_finish, "secret_item_create_finish", LIBRARY_SECRET); - Linker.link(secret_item_create_sync, "secret_item_create_sync", LIBRARY_SECRET); - Linker.link(secret_item_load_secrets, "secret_item_load_secrets", LIBRARY_SECRET); - Linker.link(secret_item_load_secrets_finish, "secret_item_load_secrets_finish", LIBRARY_SECRET); - Linker.link(secret_item_load_secrets_sync, "secret_item_load_secrets_sync", LIBRARY_SECRET); - Linker.link(secret_item_new_for_dbus_path, "secret_item_new_for_dbus_path", LIBRARY_SECRET); - Linker.link(secret_item_delete, "secret_item_delete", LIBRARY_SECRET); - Linker.link(secret_item_delete_finish, "secret_item_delete_finish", LIBRARY_SECRET); - Linker.link(secret_item_delete_sync, "secret_item_delete_sync", LIBRARY_SECRET); - Linker.link(secret_item_get_attributes, "secret_item_get_attributes", LIBRARY_SECRET); - Linker.link(secret_item_get_created, "secret_item_get_created", LIBRARY_SECRET); - Linker.link(secret_item_get_flags, "secret_item_get_flags", LIBRARY_SECRET); - Linker.link(secret_item_get_label, "secret_item_get_label", LIBRARY_SECRET); - Linker.link(secret_item_get_locked, "secret_item_get_locked", LIBRARY_SECRET); - Linker.link(secret_item_get_modified, "secret_item_get_modified", LIBRARY_SECRET); - Linker.link(secret_item_get_schema_name, "secret_item_get_schema_name", LIBRARY_SECRET); - Linker.link(secret_item_get_secret, "secret_item_get_secret", LIBRARY_SECRET); - Linker.link(secret_item_get_service, "secret_item_get_service", LIBRARY_SECRET); - Linker.link(secret_item_load_secret, "secret_item_load_secret", LIBRARY_SECRET); - Linker.link(secret_item_load_secret_finish, "secret_item_load_secret_finish", LIBRARY_SECRET); - Linker.link(secret_item_load_secret_sync, "secret_item_load_secret_sync", LIBRARY_SECRET); - Linker.link(secret_item_refresh, "secret_item_refresh", LIBRARY_SECRET); - Linker.link(secret_item_set_attributes, "secret_item_set_attributes", LIBRARY_SECRET); - Linker.link(secret_item_set_attributes_finish, "secret_item_set_attributes_finish", LIBRARY_SECRET); - Linker.link(secret_item_set_attributes_sync, "secret_item_set_attributes_sync", LIBRARY_SECRET); - Linker.link(secret_item_set_label, "secret_item_set_label", LIBRARY_SECRET); - Linker.link(secret_item_set_label_finish, "secret_item_set_label_finish", LIBRARY_SECRET); - Linker.link(secret_item_set_label_sync, "secret_item_set_label_sync", LIBRARY_SECRET); - Linker.link(secret_item_set_secret, "secret_item_set_secret", LIBRARY_SECRET); - Linker.link(secret_item_set_secret_finish, "secret_item_set_secret_finish", LIBRARY_SECRET); - Linker.link(secret_item_set_secret_sync, "secret_item_set_secret_sync", LIBRARY_SECRET); - - // secret.Prompt - - Linker.link(secret_prompt_get_type, "secret_prompt_get_type", LIBRARY_SECRET); - Linker.link(secret_prompt_perform, "secret_prompt_perform", LIBRARY_SECRET); - Linker.link(secret_prompt_perform_finish, "secret_prompt_perform_finish", LIBRARY_SECRET); - Linker.link(secret_prompt_perform_sync, "secret_prompt_perform_sync", LIBRARY_SECRET); - Linker.link(secret_prompt_run, "secret_prompt_run", LIBRARY_SECRET); - - // secret.Schema - - Linker.link(secret_schema_get_type, "secret_schema_get_type", LIBRARY_SECRET); - Linker.link(secret_schema_new, "secret_schema_new", LIBRARY_SECRET); - Linker.link(secret_schema_newv, "secret_schema_newv", LIBRARY_SECRET); - Linker.link(secret_schema_ref, "secret_schema_ref", LIBRARY_SECRET); - Linker.link(secret_schema_unref, "secret_schema_unref", LIBRARY_SECRET); - - // secret.SchemaAttribute - - Linker.link(secret_schema_attribute_get_type, "secret_schema_attribute_get_type", LIBRARY_SECRET); - - // secret.Service - - Linker.link(secret_service_get_type, "secret_service_get_type", LIBRARY_SECRET); - Linker.link(secret_service_disconnect, "secret_service_disconnect", LIBRARY_SECRET); - Linker.link(secret_service_get, "secret_service_get", LIBRARY_SECRET); - Linker.link(secret_service_get_finish, "secret_service_get_finish", LIBRARY_SECRET); - Linker.link(secret_service_get_sync, "secret_service_get_sync", LIBRARY_SECRET); - Linker.link(secret_service_open, "secret_service_open", LIBRARY_SECRET); - Linker.link(secret_service_open_finish, "secret_service_open_finish", LIBRARY_SECRET); - Linker.link(secret_service_open_sync, "secret_service_open_sync", LIBRARY_SECRET); - Linker.link(secret_service_clear, "secret_service_clear", LIBRARY_SECRET); - Linker.link(secret_service_clear_finish, "secret_service_clear_finish", LIBRARY_SECRET); - Linker.link(secret_service_clear_sync, "secret_service_clear_sync", LIBRARY_SECRET); - Linker.link(secret_service_create_collection_dbus_path, "secret_service_create_collection_dbus_path", LIBRARY_SECRET); - Linker.link(secret_service_create_collection_dbus_path_finish, "secret_service_create_collection_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_service_create_collection_dbus_path_sync, "secret_service_create_collection_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_service_create_item_dbus_path, "secret_service_create_item_dbus_path", LIBRARY_SECRET); - Linker.link(secret_service_create_item_dbus_path_finish, "secret_service_create_item_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_service_create_item_dbus_path_sync, "secret_service_create_item_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_service_decode_dbus_secret, "secret_service_decode_dbus_secret", LIBRARY_SECRET); - Linker.link(secret_service_delete_item_dbus_path, "secret_service_delete_item_dbus_path", LIBRARY_SECRET); - Linker.link(secret_service_delete_item_dbus_path_finish, "secret_service_delete_item_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_service_delete_item_dbus_path_sync, "secret_service_delete_item_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_service_encode_dbus_secret, "secret_service_encode_dbus_secret", LIBRARY_SECRET); - Linker.link(secret_service_ensure_session, "secret_service_ensure_session", LIBRARY_SECRET); - Linker.link(secret_service_ensure_session_finish, "secret_service_ensure_session_finish", LIBRARY_SECRET); - Linker.link(secret_service_ensure_session_sync, "secret_service_ensure_session_sync", LIBRARY_SECRET); - Linker.link(secret_service_get_collection_gtype, "secret_service_get_collection_gtype", LIBRARY_SECRET); - Linker.link(secret_service_get_collections, "secret_service_get_collections", LIBRARY_SECRET); - Linker.link(secret_service_get_flags, "secret_service_get_flags", LIBRARY_SECRET); - Linker.link(secret_service_get_item_gtype, "secret_service_get_item_gtype", LIBRARY_SECRET); - Linker.link(secret_service_get_secret_for_dbus_path, "secret_service_get_secret_for_dbus_path", LIBRARY_SECRET); - Linker.link(secret_service_get_secret_for_dbus_path_finish, "secret_service_get_secret_for_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_service_get_secret_for_dbus_path_sync, "secret_service_get_secret_for_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_service_get_secrets_for_dbus_paths, "secret_service_get_secrets_for_dbus_paths", LIBRARY_SECRET); - Linker.link(secret_service_get_secrets_for_dbus_paths_finish, "secret_service_get_secrets_for_dbus_paths_finish", LIBRARY_SECRET); - Linker.link(secret_service_get_secrets_for_dbus_paths_sync, "secret_service_get_secrets_for_dbus_paths_sync", LIBRARY_SECRET); - Linker.link(secret_service_get_session_algorithms, "secret_service_get_session_algorithms", LIBRARY_SECRET); - Linker.link(secret_service_get_session_dbus_path, "secret_service_get_session_dbus_path", LIBRARY_SECRET); - Linker.link(secret_service_load_collections, "secret_service_load_collections", LIBRARY_SECRET); - Linker.link(secret_service_load_collections_finish, "secret_service_load_collections_finish", LIBRARY_SECRET); - Linker.link(secret_service_load_collections_sync, "secret_service_load_collections_sync", LIBRARY_SECRET); - Linker.link(secret_service_lock, "secret_service_lock", LIBRARY_SECRET); - Linker.link(secret_service_lock_dbus_paths, "secret_service_lock_dbus_paths", LIBRARY_SECRET); - Linker.link(secret_service_lock_dbus_paths_finish, "secret_service_lock_dbus_paths_finish", LIBRARY_SECRET); - Linker.link(secret_service_lock_dbus_paths_sync, "secret_service_lock_dbus_paths_sync", LIBRARY_SECRET); - Linker.link(secret_service_lock_finish, "secret_service_lock_finish", LIBRARY_SECRET); - Linker.link(secret_service_lock_sync, "secret_service_lock_sync", LIBRARY_SECRET); - Linker.link(secret_service_lookup, "secret_service_lookup", LIBRARY_SECRET); - Linker.link(secret_service_lookup_finish, "secret_service_lookup_finish", LIBRARY_SECRET); - Linker.link(secret_service_lookup_sync, "secret_service_lookup_sync", LIBRARY_SECRET); - Linker.link(secret_service_prompt, "secret_service_prompt", LIBRARY_SECRET); - Linker.link(secret_service_prompt_at_dbus_path, "secret_service_prompt_at_dbus_path", LIBRARY_SECRET); - Linker.link(secret_service_prompt_at_dbus_path_finish, "secret_service_prompt_at_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_service_prompt_at_dbus_path_sync, "secret_service_prompt_at_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_service_prompt_finish, "secret_service_prompt_finish", LIBRARY_SECRET); - Linker.link(secret_service_prompt_sync, "secret_service_prompt_sync", LIBRARY_SECRET); - Linker.link(secret_service_read_alias_dbus_path, "secret_service_read_alias_dbus_path", LIBRARY_SECRET); - Linker.link(secret_service_read_alias_dbus_path_finish, "secret_service_read_alias_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_service_read_alias_dbus_path_sync, "secret_service_read_alias_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_service_search, "secret_service_search", LIBRARY_SECRET); - Linker.link(secret_service_search_finish, "secret_service_search_finish", LIBRARY_SECRET); - Linker.link(secret_service_search_for_dbus_paths, "secret_service_search_for_dbus_paths", LIBRARY_SECRET); - Linker.link(secret_service_search_for_dbus_paths_finish, "secret_service_search_for_dbus_paths_finish", LIBRARY_SECRET); - Linker.link(secret_service_search_for_dbus_paths_sync, "secret_service_search_for_dbus_paths_sync", LIBRARY_SECRET); - Linker.link(secret_service_search_sync, "secret_service_search_sync", LIBRARY_SECRET); - Linker.link(secret_service_set_alias, "secret_service_set_alias", LIBRARY_SECRET); - Linker.link(secret_service_set_alias_finish, "secret_service_set_alias_finish", LIBRARY_SECRET); - Linker.link(secret_service_set_alias_sync, "secret_service_set_alias_sync", LIBRARY_SECRET); - Linker.link(secret_service_set_alias_to_dbus_path, "secret_service_set_alias_to_dbus_path", LIBRARY_SECRET); - Linker.link(secret_service_set_alias_to_dbus_path_finish, "secret_service_set_alias_to_dbus_path_finish", LIBRARY_SECRET); - Linker.link(secret_service_set_alias_to_dbus_path_sync, "secret_service_set_alias_to_dbus_path_sync", LIBRARY_SECRET); - Linker.link(secret_service_store, "secret_service_store", LIBRARY_SECRET); - Linker.link(secret_service_store_finish, "secret_service_store_finish", LIBRARY_SECRET); - Linker.link(secret_service_store_sync, "secret_service_store_sync", LIBRARY_SECRET); - Linker.link(secret_service_unlock, "secret_service_unlock", LIBRARY_SECRET); - Linker.link(secret_service_unlock_dbus_paths, "secret_service_unlock_dbus_paths", LIBRARY_SECRET); - Linker.link(secret_service_unlock_dbus_paths_finish, "secret_service_unlock_dbus_paths_finish", LIBRARY_SECRET); - Linker.link(secret_service_unlock_dbus_paths_sync, "secret_service_unlock_dbus_paths_sync", LIBRARY_SECRET); - Linker.link(secret_service_unlock_finish, "secret_service_unlock_finish", LIBRARY_SECRET); - Linker.link(secret_service_unlock_sync, "secret_service_unlock_sync", LIBRARY_SECRET); - - // secret.Value - - Linker.link(secret_value_get_type, "secret_value_get_type", LIBRARY_SECRET); - Linker.link(secret_value_new, "secret_value_new", LIBRARY_SECRET); - Linker.link(secret_value_new_full, "secret_value_new_full", LIBRARY_SECRET); - Linker.link(secret_value_get, "secret_value_get", LIBRARY_SECRET); - Linker.link(secret_value_get_content_type, "secret_value_get_content_type", LIBRARY_SECRET); - Linker.link(secret_value_get_text, "secret_value_get_text", LIBRARY_SECRET); - Linker.link(secret_value_ref, "secret_value_ref", LIBRARY_SECRET); - Linker.link(secret_value_unref, "secret_value_unref", LIBRARY_SECRET); - - // secret.Secret - - Linker.link(secret_password_clear, "secret_password_clear", LIBRARY_SECRET); - Linker.link(secret_password_clear_finish, "secret_password_clear_finish", LIBRARY_SECRET); - Linker.link(secret_password_clear_sync, "secret_password_clear_sync", LIBRARY_SECRET); - Linker.link(secret_password_clearv, "secret_password_clearv", LIBRARY_SECRET); - Linker.link(secret_password_clearv_sync, "secret_password_clearv_sync", LIBRARY_SECRET); - Linker.link(secret_password_free, "secret_password_free", LIBRARY_SECRET); - Linker.link(secret_password_lookup, "secret_password_lookup", LIBRARY_SECRET); - Linker.link(secret_password_lookup_finish, "secret_password_lookup_finish", LIBRARY_SECRET); - Linker.link(secret_password_lookup_nonpageable_finish, "secret_password_lookup_nonpageable_finish", LIBRARY_SECRET); - Linker.link(secret_password_lookup_nonpageable_sync, "secret_password_lookup_nonpageable_sync", LIBRARY_SECRET); - Linker.link(secret_password_lookup_sync, "secret_password_lookup_sync", LIBRARY_SECRET); - Linker.link(secret_password_lookupv, "secret_password_lookupv", LIBRARY_SECRET); - Linker.link(secret_password_lookupv_nonpageable_sync, "secret_password_lookupv_nonpageable_sync", LIBRARY_SECRET); - Linker.link(secret_password_lookupv_sync, "secret_password_lookupv_sync", LIBRARY_SECRET); - Linker.link(secret_password_store, "secret_password_store", LIBRARY_SECRET); - Linker.link(secret_password_store_finish, "secret_password_store_finish", LIBRARY_SECRET); - Linker.link(secret_password_store_sync, "secret_password_store_sync", LIBRARY_SECRET); - Linker.link(secret_password_storev, "secret_password_storev", LIBRARY_SECRET); - Linker.link(secret_password_storev_sync, "secret_password_storev_sync", LIBRARY_SECRET); - Linker.link(secret_password_wipe, "secret_password_wipe", LIBRARY_SECRET); -} - -__gshared extern(C) -{ - - // secret.Collection - - GType function() c_secret_collection_get_type; - SecretCollection* function(GAsyncResult* result, GError** err) c_secret_collection_new_for_dbus_path_finish; - SecretCollection* function(SecretService* service, const(char)* collectionPath, SecretCollectionFlags flags, GCancellable* cancellable, GError** err) c_secret_collection_new_for_dbus_path_sync; - void function(SecretService* service, const(char)* label, const(char)* alias_, SecretCollectionCreateFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_collection_create; - SecretCollection* function(GAsyncResult* result, GError** err) c_secret_collection_create_finish; - SecretCollection* function(SecretService* service, const(char)* label, const(char)* alias_, SecretCollectionCreateFlags flags, GCancellable* cancellable, GError** err) c_secret_collection_create_sync; - void function(SecretService* service, const(char)* alias_, SecretCollectionFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_collection_for_alias; - SecretCollection* function(GAsyncResult* result, GError** err) c_secret_collection_for_alias_finish; - SecretCollection* function(SecretService* service, const(char)* alias_, SecretCollectionFlags flags, GCancellable* cancellable, GError** err) c_secret_collection_for_alias_sync; - void function(SecretService* service, const(char)* collectionPath, SecretCollectionFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_collection_new_for_dbus_path; - void function(SecretCollection* self, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_collection_delete; - int function(SecretCollection* self, GAsyncResult* result, GError** err) c_secret_collection_delete_finish; - int function(SecretCollection* self, GCancellable* cancellable, GError** err) c_secret_collection_delete_sync; - ulong function(SecretCollection* self) c_secret_collection_get_created; - SecretCollectionFlags function(SecretCollection* self) c_secret_collection_get_flags; - GList* function(SecretCollection* self) c_secret_collection_get_items; - char* function(SecretCollection* self) c_secret_collection_get_label; - int function(SecretCollection* self) c_secret_collection_get_locked; - ulong function(SecretCollection* self) c_secret_collection_get_modified; - SecretService* function(SecretCollection* self) c_secret_collection_get_service; - void function(SecretCollection* self, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_collection_load_items; - int function(SecretCollection* self, GAsyncResult* result, GError** err) c_secret_collection_load_items_finish; - int function(SecretCollection* self, GCancellable* cancellable, GError** err) c_secret_collection_load_items_sync; - void function(SecretCollection* self) c_secret_collection_refresh; - void function(SecretCollection* self, SecretSchema* schema, GHashTable* attributes, SecretSearchFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_collection_search; - GList* function(SecretCollection* self, GAsyncResult* result, GError** err) c_secret_collection_search_finish; - void function(SecretCollection* collection, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_collection_search_for_dbus_paths; - char** function(SecretCollection* collection, GAsyncResult* result, GError** err) c_secret_collection_search_for_dbus_paths_finish; - char** function(SecretCollection* collection, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GError** err) c_secret_collection_search_for_dbus_paths_sync; - GList* function(SecretCollection* self, SecretSchema* schema, GHashTable* attributes, SecretSearchFlags flags, GCancellable* cancellable, GError** err) c_secret_collection_search_sync; - void function(SecretCollection* self, const(char)* label, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_collection_set_label; - int function(SecretCollection* self, GAsyncResult* result, GError** err) c_secret_collection_set_label_finish; - int function(SecretCollection* self, const(char)* label, GCancellable* cancellable, GError** err) c_secret_collection_set_label_sync; - - // secret.Item - - GType function() c_secret_item_get_type; - SecretItem* function(GAsyncResult* result, GError** err) c_secret_item_new_for_dbus_path_finish; - SecretItem* function(SecretService* service, const(char)* itemPath, SecretItemFlags flags, GCancellable* cancellable, GError** err) c_secret_item_new_for_dbus_path_sync; - void function(SecretCollection* collection, SecretSchema* schema, GHashTable* attributes, const(char)* label, SecretValue* value, SecretItemCreateFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_item_create; - SecretItem* function(GAsyncResult* result, GError** err) c_secret_item_create_finish; - SecretItem* function(SecretCollection* collection, SecretSchema* schema, GHashTable* attributes, const(char)* label, SecretValue* value, SecretItemCreateFlags flags, GCancellable* cancellable, GError** err) c_secret_item_create_sync; - void function(GList* items, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_item_load_secrets; - int function(GAsyncResult* result, GError** err) c_secret_item_load_secrets_finish; - int function(GList* items, GCancellable* cancellable, GError** err) c_secret_item_load_secrets_sync; - void function(SecretService* service, const(char)* itemPath, SecretItemFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_item_new_for_dbus_path; - void function(SecretItem* self, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_item_delete; - int function(SecretItem* self, GAsyncResult* result, GError** err) c_secret_item_delete_finish; - int function(SecretItem* self, GCancellable* cancellable, GError** err) c_secret_item_delete_sync; - GHashTable* function(SecretItem* self) c_secret_item_get_attributes; - ulong function(SecretItem* self) c_secret_item_get_created; - SecretItemFlags function(SecretItem* self) c_secret_item_get_flags; - char* function(SecretItem* self) c_secret_item_get_label; - int function(SecretItem* self) c_secret_item_get_locked; - ulong function(SecretItem* self) c_secret_item_get_modified; - char* function(SecretItem* self) c_secret_item_get_schema_name; - SecretValue* function(SecretItem* self) c_secret_item_get_secret; - SecretService* function(SecretItem* self) c_secret_item_get_service; - void function(SecretItem* self, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_item_load_secret; - int function(SecretItem* self, GAsyncResult* result, GError** err) c_secret_item_load_secret_finish; - int function(SecretItem* self, GCancellable* cancellable, GError** err) c_secret_item_load_secret_sync; - void function(SecretItem* self) c_secret_item_refresh; - void function(SecretItem* self, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_item_set_attributes; - int function(SecretItem* self, GAsyncResult* result, GError** err) c_secret_item_set_attributes_finish; - int function(SecretItem* self, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GError** err) c_secret_item_set_attributes_sync; - void function(SecretItem* self, const(char)* label, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_item_set_label; - int function(SecretItem* self, GAsyncResult* result, GError** err) c_secret_item_set_label_finish; - int function(SecretItem* self, const(char)* label, GCancellable* cancellable, GError** err) c_secret_item_set_label_sync; - void function(SecretItem* self, SecretValue* value, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_item_set_secret; - int function(SecretItem* self, GAsyncResult* result, GError** err) c_secret_item_set_secret_finish; - int function(SecretItem* self, SecretValue* value, GCancellable* cancellable, GError** err) c_secret_item_set_secret_sync; - - // secret.Prompt - - GType function() c_secret_prompt_get_type; - void function(SecretPrompt* self, const(char)* windowId, GVariantType* returnType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_prompt_perform; - GVariant* function(SecretPrompt* self, GAsyncResult* result, GError** err) c_secret_prompt_perform_finish; - GVariant* function(SecretPrompt* self, const(char)* windowId, GCancellable* cancellable, GVariantType* returnType, GError** err) c_secret_prompt_perform_sync; - GVariant* function(SecretPrompt* self, const(char)* windowId, GCancellable* cancellable, GVariantType* returnType, GError** err) c_secret_prompt_run; - - // secret.Schema - - GType function() c_secret_schema_get_type; - SecretSchema* function(const(char)* name, SecretSchemaFlags flags, ... ) c_secret_schema_new; - SecretSchema* function(const(char)* name, SecretSchemaFlags flags, GHashTable* attributeNamesAndTypes) c_secret_schema_newv; - SecretSchema* function(SecretSchema* schema) c_secret_schema_ref; - void function(SecretSchema* schema) c_secret_schema_unref; - - // secret.SchemaAttribute - - GType function() c_secret_schema_attribute_get_type; - - // secret.Service - - GType function() c_secret_service_get_type; - void function() c_secret_service_disconnect; - void function(SecretServiceFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_get; - SecretService* function(GAsyncResult* result, GError** err) c_secret_service_get_finish; - SecretService* function(SecretServiceFlags flags, GCancellable* cancellable, GError** err) c_secret_service_get_sync; - void function(GType serviceGtype, const(char)* serviceBusName, SecretServiceFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_open; - SecretService* function(GAsyncResult* result, GError** err) c_secret_service_open_finish; - SecretService* function(GType serviceGtype, const(char)* serviceBusName, SecretServiceFlags flags, GCancellable* cancellable, GError** err) c_secret_service_open_sync; - void function(SecretService* service, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_clear; - int function(SecretService* service, GAsyncResult* result, GError** err) c_secret_service_clear_finish; - int function(SecretService* service, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GError** err) c_secret_service_clear_sync; - void function(SecretService* self, GHashTable* properties, const(char)* alias_, SecretCollectionCreateFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_create_collection_dbus_path; - char* function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_create_collection_dbus_path_finish; - char* function(SecretService* self, GHashTable* properties, const(char)* alias_, SecretCollectionCreateFlags flags, GCancellable* cancellable, GError** err) c_secret_service_create_collection_dbus_path_sync; - void function(SecretService* self, const(char)* collectionPath, GHashTable* properties, SecretValue* value, SecretItemCreateFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_create_item_dbus_path; - char* function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_create_item_dbus_path_finish; - char* function(SecretService* self, const(char)* collectionPath, GHashTable* properties, SecretValue* value, SecretItemCreateFlags flags, GCancellable* cancellable, GError** err) c_secret_service_create_item_dbus_path_sync; - SecretValue* function(SecretService* service, GVariant* value) c_secret_service_decode_dbus_secret; - void function(SecretService* self, const(char)* itemPath, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_delete_item_dbus_path; - int function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_delete_item_dbus_path_finish; - int function(SecretService* self, const(char)* itemPath, GCancellable* cancellable, GError** err) c_secret_service_delete_item_dbus_path_sync; - GVariant* function(SecretService* service, SecretValue* value) c_secret_service_encode_dbus_secret; - void function(SecretService* self, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_ensure_session; - int function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_ensure_session_finish; - int function(SecretService* self, GCancellable* cancellable, GError** err) c_secret_service_ensure_session_sync; - GType function(SecretService* self) c_secret_service_get_collection_gtype; - GList* function(SecretService* self) c_secret_service_get_collections; - SecretServiceFlags function(SecretService* self) c_secret_service_get_flags; - GType function(SecretService* self) c_secret_service_get_item_gtype; - void function(SecretService* self, const(char)* itemPath, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_get_secret_for_dbus_path; - SecretValue* function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_get_secret_for_dbus_path_finish; - SecretValue* function(SecretService* self, const(char)* itemPath, GCancellable* cancellable, GError** err) c_secret_service_get_secret_for_dbus_path_sync; - void function(SecretService* self, char** itemPaths, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_get_secrets_for_dbus_paths; - GHashTable* function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_get_secrets_for_dbus_paths_finish; - GHashTable* function(SecretService* self, char** itemPaths, GCancellable* cancellable, GError** err) c_secret_service_get_secrets_for_dbus_paths_sync; - const(char)* function(SecretService* self) c_secret_service_get_session_algorithms; - const(char)* function(SecretService* self) c_secret_service_get_session_dbus_path; - void function(SecretService* self, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_load_collections; - int function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_load_collections_finish; - int function(SecretService* self, GCancellable* cancellable, GError** err) c_secret_service_load_collections_sync; - void function(SecretService* service, GList* objects, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_lock; - void function(SecretService* self, char** paths, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_lock_dbus_paths; - int function(SecretService* self, GAsyncResult* result, char*** locked, GError** err) c_secret_service_lock_dbus_paths_finish; - int function(SecretService* self, char** paths, GCancellable* cancellable, char*** locked, GError** err) c_secret_service_lock_dbus_paths_sync; - int function(SecretService* service, GAsyncResult* result, GList** locked, GError** err) c_secret_service_lock_finish; - int function(SecretService* service, GList* objects, GCancellable* cancellable, GList** locked, GError** err) c_secret_service_lock_sync; - void function(SecretService* service, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_lookup; - SecretValue* function(SecretService* service, GAsyncResult* result, GError** err) c_secret_service_lookup_finish; - SecretValue* function(SecretService* service, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GError** err) c_secret_service_lookup_sync; - void function(SecretService* self, SecretPrompt* prompt, GVariantType* returnType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_prompt; - void function(SecretService* self, const(char)* promptPath, GVariantType* returnType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_prompt_at_dbus_path; - GVariant* function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_prompt_at_dbus_path_finish; - GVariant* function(SecretService* self, const(char)* promptPath, GCancellable* cancellable, GVariantType* returnType, GError** err) c_secret_service_prompt_at_dbus_path_sync; - GVariant* function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_prompt_finish; - GVariant* function(SecretService* self, SecretPrompt* prompt, GCancellable* cancellable, GVariantType* returnType, GError** err) c_secret_service_prompt_sync; - void function(SecretService* self, const(char)* alias_, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_read_alias_dbus_path; - char* function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_read_alias_dbus_path_finish; - char* function(SecretService* self, const(char)* alias_, GCancellable* cancellable, GError** err) c_secret_service_read_alias_dbus_path_sync; - void function(SecretService* service, SecretSchema* schema, GHashTable* attributes, SecretSearchFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_search; - GList* function(SecretService* service, GAsyncResult* result, GError** err) c_secret_service_search_finish; - void function(SecretService* self, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_search_for_dbus_paths; - int function(SecretService* self, GAsyncResult* result, char*** unlocked, char*** locked, GError** err) c_secret_service_search_for_dbus_paths_finish; - int function(SecretService* self, SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, char*** unlocked, char*** locked, GError** err) c_secret_service_search_for_dbus_paths_sync; - GList* function(SecretService* service, SecretSchema* schema, GHashTable* attributes, SecretSearchFlags flags, GCancellable* cancellable, GError** err) c_secret_service_search_sync; - void function(SecretService* service, const(char)* alias_, SecretCollection* collection, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_set_alias; - int function(SecretService* service, GAsyncResult* result, GError** err) c_secret_service_set_alias_finish; - int function(SecretService* service, const(char)* alias_, SecretCollection* collection, GCancellable* cancellable, GError** err) c_secret_service_set_alias_sync; - void function(SecretService* self, const(char)* alias_, const(char)* collectionPath, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_set_alias_to_dbus_path; - int function(SecretService* self, GAsyncResult* result, GError** err) c_secret_service_set_alias_to_dbus_path_finish; - int function(SecretService* self, const(char)* alias_, const(char)* collectionPath, GCancellable* cancellable, GError** err) c_secret_service_set_alias_to_dbus_path_sync; - void function(SecretService* service, SecretSchema* schema, GHashTable* attributes, const(char)* collection, const(char)* label, SecretValue* value, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_store; - int function(SecretService* service, GAsyncResult* result, GError** err) c_secret_service_store_finish; - int function(SecretService* service, SecretSchema* schema, GHashTable* attributes, const(char)* collection, const(char)* label, SecretValue* value, GCancellable* cancellable, GError** err) c_secret_service_store_sync; - void function(SecretService* service, GList* objects, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_unlock; - void function(SecretService* self, char** paths, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_service_unlock_dbus_paths; - int function(SecretService* self, GAsyncResult* result, char*** unlocked, GError** err) c_secret_service_unlock_dbus_paths_finish; - int function(SecretService* self, char** paths, GCancellable* cancellable, char*** unlocked, GError** err) c_secret_service_unlock_dbus_paths_sync; - int function(SecretService* service, GAsyncResult* result, GList** unlocked, GError** err) c_secret_service_unlock_finish; - int function(SecretService* service, GList* objects, GCancellable* cancellable, GList** unlocked, GError** err) c_secret_service_unlock_sync; - - // secret.Value - - GType function() c_secret_value_get_type; - SecretValue* function(const(char)* secret, ptrdiff_t length, const(char)* contentType) c_secret_value_new; - SecretValue* function(char* secret, ptrdiff_t length, const(char)* contentType, GDestroyNotify destroy) c_secret_value_new_full; - char* function(SecretValue* value, size_t* length) c_secret_value_get; - const(char)* function(SecretValue* value) c_secret_value_get_content_type; - const(char)* function(SecretValue* value) c_secret_value_get_text; - SecretValue* function(SecretValue* value) c_secret_value_ref; - void function(void* value) c_secret_value_unref; - - // secret.Secret - - void function(SecretSchema* schema, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData, ... ) c_secret_password_clear; - int function(GAsyncResult* result, GError** err) c_secret_password_clear_finish; - int function(SecretSchema* schema, GCancellable* cancellable, GError** error, ... ) c_secret_password_clear_sync; - void function(SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_password_clearv; - int function(SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GError** err) c_secret_password_clearv_sync; - void function(char* password) c_secret_password_free; - void function(SecretSchema* schema, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData, ... ) c_secret_password_lookup; - char* function(GAsyncResult* result, GError** err) c_secret_password_lookup_finish; - char* function(GAsyncResult* result, GError** err) c_secret_password_lookup_nonpageable_finish; - char* function(SecretSchema* schema, GCancellable* cancellable, GError** error, ... ) c_secret_password_lookup_nonpageable_sync; - char* function(SecretSchema* schema, GCancellable* cancellable, GError** error, ... ) c_secret_password_lookup_sync; - void function(SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_password_lookupv; - char* function(SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GError** err) c_secret_password_lookupv_nonpageable_sync; - char* function(SecretSchema* schema, GHashTable* attributes, GCancellable* cancellable, GError** err) c_secret_password_lookupv_sync; - void function(SecretSchema* schema, const(char)* collection, const(char)* label, const(char)* password, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData, ... ) c_secret_password_store; - int function(GAsyncResult* result, GError** err) c_secret_password_store_finish; - int function(SecretSchema* schema, const(char)* collection, const(char)* label, const(char)* password, GCancellable* cancellable, GError** error, ... ) c_secret_password_store_sync; - void function(SecretSchema* schema, GHashTable* attributes, const(char)* collection, const(char)* label, const(char)* password, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) c_secret_password_storev; - int function(SecretSchema* schema, GHashTable* attributes, const(char)* collection, const(char)* label, const(char)* password, GCancellable* cancellable, GError** err) c_secret_password_storev_sync; - void function(char* password) c_secret_password_wipe; -} - - -// secret.Collection - -alias c_secret_collection_get_type secret_collection_get_type; -alias c_secret_collection_new_for_dbus_path_finish secret_collection_new_for_dbus_path_finish; -alias c_secret_collection_new_for_dbus_path_sync secret_collection_new_for_dbus_path_sync; -alias c_secret_collection_create secret_collection_create; -alias c_secret_collection_create_finish secret_collection_create_finish; -alias c_secret_collection_create_sync secret_collection_create_sync; -alias c_secret_collection_for_alias secret_collection_for_alias; -alias c_secret_collection_for_alias_finish secret_collection_for_alias_finish; -alias c_secret_collection_for_alias_sync secret_collection_for_alias_sync; -alias c_secret_collection_new_for_dbus_path secret_collection_new_for_dbus_path; -alias c_secret_collection_delete secret_collection_delete; -alias c_secret_collection_delete_finish secret_collection_delete_finish; -alias c_secret_collection_delete_sync secret_collection_delete_sync; -alias c_secret_collection_get_created secret_collection_get_created; -alias c_secret_collection_get_flags secret_collection_get_flags; -alias c_secret_collection_get_items secret_collection_get_items; -alias c_secret_collection_get_label secret_collection_get_label; -alias c_secret_collection_get_locked secret_collection_get_locked; -alias c_secret_collection_get_modified secret_collection_get_modified; -alias c_secret_collection_get_service secret_collection_get_service; -alias c_secret_collection_load_items secret_collection_load_items; -alias c_secret_collection_load_items_finish secret_collection_load_items_finish; -alias c_secret_collection_load_items_sync secret_collection_load_items_sync; -alias c_secret_collection_refresh secret_collection_refresh; -alias c_secret_collection_search secret_collection_search; -alias c_secret_collection_search_finish secret_collection_search_finish; -alias c_secret_collection_search_for_dbus_paths secret_collection_search_for_dbus_paths; -alias c_secret_collection_search_for_dbus_paths_finish secret_collection_search_for_dbus_paths_finish; -alias c_secret_collection_search_for_dbus_paths_sync secret_collection_search_for_dbus_paths_sync; -alias c_secret_collection_search_sync secret_collection_search_sync; -alias c_secret_collection_set_label secret_collection_set_label; -alias c_secret_collection_set_label_finish secret_collection_set_label_finish; -alias c_secret_collection_set_label_sync secret_collection_set_label_sync; - -// secret.Item - -alias c_secret_item_get_type secret_item_get_type; -alias c_secret_item_new_for_dbus_path_finish secret_item_new_for_dbus_path_finish; -alias c_secret_item_new_for_dbus_path_sync secret_item_new_for_dbus_path_sync; -alias c_secret_item_create secret_item_create; -alias c_secret_item_create_finish secret_item_create_finish; -alias c_secret_item_create_sync secret_item_create_sync; -alias c_secret_item_load_secrets secret_item_load_secrets; -alias c_secret_item_load_secrets_finish secret_item_load_secrets_finish; -alias c_secret_item_load_secrets_sync secret_item_load_secrets_sync; -alias c_secret_item_new_for_dbus_path secret_item_new_for_dbus_path; -alias c_secret_item_delete secret_item_delete; -alias c_secret_item_delete_finish secret_item_delete_finish; -alias c_secret_item_delete_sync secret_item_delete_sync; -alias c_secret_item_get_attributes secret_item_get_attributes; -alias c_secret_item_get_created secret_item_get_created; -alias c_secret_item_get_flags secret_item_get_flags; -alias c_secret_item_get_label secret_item_get_label; -alias c_secret_item_get_locked secret_item_get_locked; -alias c_secret_item_get_modified secret_item_get_modified; -alias c_secret_item_get_schema_name secret_item_get_schema_name; -alias c_secret_item_get_secret secret_item_get_secret; -alias c_secret_item_get_service secret_item_get_service; -alias c_secret_item_load_secret secret_item_load_secret; -alias c_secret_item_load_secret_finish secret_item_load_secret_finish; -alias c_secret_item_load_secret_sync secret_item_load_secret_sync; -alias c_secret_item_refresh secret_item_refresh; -alias c_secret_item_set_attributes secret_item_set_attributes; -alias c_secret_item_set_attributes_finish secret_item_set_attributes_finish; -alias c_secret_item_set_attributes_sync secret_item_set_attributes_sync; -alias c_secret_item_set_label secret_item_set_label; -alias c_secret_item_set_label_finish secret_item_set_label_finish; -alias c_secret_item_set_label_sync secret_item_set_label_sync; -alias c_secret_item_set_secret secret_item_set_secret; -alias c_secret_item_set_secret_finish secret_item_set_secret_finish; -alias c_secret_item_set_secret_sync secret_item_set_secret_sync; - -// secret.Prompt - -alias c_secret_prompt_get_type secret_prompt_get_type; -alias c_secret_prompt_perform secret_prompt_perform; -alias c_secret_prompt_perform_finish secret_prompt_perform_finish; -alias c_secret_prompt_perform_sync secret_prompt_perform_sync; -alias c_secret_prompt_run secret_prompt_run; - -// secret.Schema - -alias c_secret_schema_get_type secret_schema_get_type; -alias c_secret_schema_new secret_schema_new; -alias c_secret_schema_newv secret_schema_newv; -alias c_secret_schema_ref secret_schema_ref; -alias c_secret_schema_unref secret_schema_unref; - -// secret.SchemaAttribute - -alias c_secret_schema_attribute_get_type secret_schema_attribute_get_type; - -// secret.Service - -alias c_secret_service_get_type secret_service_get_type; -alias c_secret_service_disconnect secret_service_disconnect; -alias c_secret_service_get secret_service_get; -alias c_secret_service_get_finish secret_service_get_finish; -alias c_secret_service_get_sync secret_service_get_sync; -alias c_secret_service_open secret_service_open; -alias c_secret_service_open_finish secret_service_open_finish; -alias c_secret_service_open_sync secret_service_open_sync; -alias c_secret_service_clear secret_service_clear; -alias c_secret_service_clear_finish secret_service_clear_finish; -alias c_secret_service_clear_sync secret_service_clear_sync; -alias c_secret_service_create_collection_dbus_path secret_service_create_collection_dbus_path; -alias c_secret_service_create_collection_dbus_path_finish secret_service_create_collection_dbus_path_finish; -alias c_secret_service_create_collection_dbus_path_sync secret_service_create_collection_dbus_path_sync; -alias c_secret_service_create_item_dbus_path secret_service_create_item_dbus_path; -alias c_secret_service_create_item_dbus_path_finish secret_service_create_item_dbus_path_finish; -alias c_secret_service_create_item_dbus_path_sync secret_service_create_item_dbus_path_sync; -alias c_secret_service_decode_dbus_secret secret_service_decode_dbus_secret; -alias c_secret_service_delete_item_dbus_path secret_service_delete_item_dbus_path; -alias c_secret_service_delete_item_dbus_path_finish secret_service_delete_item_dbus_path_finish; -alias c_secret_service_delete_item_dbus_path_sync secret_service_delete_item_dbus_path_sync; -alias c_secret_service_encode_dbus_secret secret_service_encode_dbus_secret; -alias c_secret_service_ensure_session secret_service_ensure_session; -alias c_secret_service_ensure_session_finish secret_service_ensure_session_finish; -alias c_secret_service_ensure_session_sync secret_service_ensure_session_sync; -alias c_secret_service_get_collection_gtype secret_service_get_collection_gtype; -alias c_secret_service_get_collections secret_service_get_collections; -alias c_secret_service_get_flags secret_service_get_flags; -alias c_secret_service_get_item_gtype secret_service_get_item_gtype; -alias c_secret_service_get_secret_for_dbus_path secret_service_get_secret_for_dbus_path; -alias c_secret_service_get_secret_for_dbus_path_finish secret_service_get_secret_for_dbus_path_finish; -alias c_secret_service_get_secret_for_dbus_path_sync secret_service_get_secret_for_dbus_path_sync; -alias c_secret_service_get_secrets_for_dbus_paths secret_service_get_secrets_for_dbus_paths; -alias c_secret_service_get_secrets_for_dbus_paths_finish secret_service_get_secrets_for_dbus_paths_finish; -alias c_secret_service_get_secrets_for_dbus_paths_sync secret_service_get_secrets_for_dbus_paths_sync; -alias c_secret_service_get_session_algorithms secret_service_get_session_algorithms; -alias c_secret_service_get_session_dbus_path secret_service_get_session_dbus_path; -alias c_secret_service_load_collections secret_service_load_collections; -alias c_secret_service_load_collections_finish secret_service_load_collections_finish; -alias c_secret_service_load_collections_sync secret_service_load_collections_sync; -alias c_secret_service_lock secret_service_lock; -alias c_secret_service_lock_dbus_paths secret_service_lock_dbus_paths; -alias c_secret_service_lock_dbus_paths_finish secret_service_lock_dbus_paths_finish; -alias c_secret_service_lock_dbus_paths_sync secret_service_lock_dbus_paths_sync; -alias c_secret_service_lock_finish secret_service_lock_finish; -alias c_secret_service_lock_sync secret_service_lock_sync; -alias c_secret_service_lookup secret_service_lookup; -alias c_secret_service_lookup_finish secret_service_lookup_finish; -alias c_secret_service_lookup_sync secret_service_lookup_sync; -alias c_secret_service_prompt secret_service_prompt; -alias c_secret_service_prompt_at_dbus_path secret_service_prompt_at_dbus_path; -alias c_secret_service_prompt_at_dbus_path_finish secret_service_prompt_at_dbus_path_finish; -alias c_secret_service_prompt_at_dbus_path_sync secret_service_prompt_at_dbus_path_sync; -alias c_secret_service_prompt_finish secret_service_prompt_finish; -alias c_secret_service_prompt_sync secret_service_prompt_sync; -alias c_secret_service_read_alias_dbus_path secret_service_read_alias_dbus_path; -alias c_secret_service_read_alias_dbus_path_finish secret_service_read_alias_dbus_path_finish; -alias c_secret_service_read_alias_dbus_path_sync secret_service_read_alias_dbus_path_sync; -alias c_secret_service_search secret_service_search; -alias c_secret_service_search_finish secret_service_search_finish; -alias c_secret_service_search_for_dbus_paths secret_service_search_for_dbus_paths; -alias c_secret_service_search_for_dbus_paths_finish secret_service_search_for_dbus_paths_finish; -alias c_secret_service_search_for_dbus_paths_sync secret_service_search_for_dbus_paths_sync; -alias c_secret_service_search_sync secret_service_search_sync; -alias c_secret_service_set_alias secret_service_set_alias; -alias c_secret_service_set_alias_finish secret_service_set_alias_finish; -alias c_secret_service_set_alias_sync secret_service_set_alias_sync; -alias c_secret_service_set_alias_to_dbus_path secret_service_set_alias_to_dbus_path; -alias c_secret_service_set_alias_to_dbus_path_finish secret_service_set_alias_to_dbus_path_finish; -alias c_secret_service_set_alias_to_dbus_path_sync secret_service_set_alias_to_dbus_path_sync; -alias c_secret_service_store secret_service_store; -alias c_secret_service_store_finish secret_service_store_finish; -alias c_secret_service_store_sync secret_service_store_sync; -alias c_secret_service_unlock secret_service_unlock; -alias c_secret_service_unlock_dbus_paths secret_service_unlock_dbus_paths; -alias c_secret_service_unlock_dbus_paths_finish secret_service_unlock_dbus_paths_finish; -alias c_secret_service_unlock_dbus_paths_sync secret_service_unlock_dbus_paths_sync; -alias c_secret_service_unlock_finish secret_service_unlock_finish; -alias c_secret_service_unlock_sync secret_service_unlock_sync; - -// secret.Value - -alias c_secret_value_get_type secret_value_get_type; -alias c_secret_value_new secret_value_new; -alias c_secret_value_new_full secret_value_new_full; -alias c_secret_value_get secret_value_get; -alias c_secret_value_get_content_type secret_value_get_content_type; -alias c_secret_value_get_text secret_value_get_text; -alias c_secret_value_ref secret_value_ref; -alias c_secret_value_unref secret_value_unref; - -// secret.Secret - -alias c_secret_password_clear secret_password_clear; -alias c_secret_password_clear_finish secret_password_clear_finish; -alias c_secret_password_clear_sync secret_password_clear_sync; -alias c_secret_password_clearv secret_password_clearv; -alias c_secret_password_clearv_sync secret_password_clearv_sync; -alias c_secret_password_free secret_password_free; -alias c_secret_password_lookup secret_password_lookup; -alias c_secret_password_lookup_finish secret_password_lookup_finish; -alias c_secret_password_lookup_nonpageable_finish secret_password_lookup_nonpageable_finish; -alias c_secret_password_lookup_nonpageable_sync secret_password_lookup_nonpageable_sync; -alias c_secret_password_lookup_sync secret_password_lookup_sync; -alias c_secret_password_lookupv secret_password_lookupv; -alias c_secret_password_lookupv_nonpageable_sync secret_password_lookupv_nonpageable_sync; -alias c_secret_password_lookupv_sync secret_password_lookupv_sync; -alias c_secret_password_store secret_password_store; -alias c_secret_password_store_finish secret_password_store_finish; -alias c_secret_password_store_sync secret_password_store_sync; -alias c_secret_password_storev secret_password_storev; -alias c_secret_password_storev_sync secret_password_storev_sync; -alias c_secret_password_wipe secret_password_wipe; diff --git a/source/secretc/secrettypes.d b/source/secretc/secrettypes.d deleted file mode 100644 index a4a1473a3..000000000 --- a/source/secretc/secrettypes.d +++ /dev/null @@ -1,353 +0,0 @@ -/* - * This file is part of gtkD. - * - * gtkD is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 - * of the License, or (at your option) any later version, with - * some exceptions, please read the COPYING file. - * - * gtkD is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with gtkD; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA - */ - -// generated automatically - do not change -// find conversion definition on APILookup.txt -// implement new conversion functionalities on the wrap.utils pakage - - -module secretc.secrettypes; - -public import gtkc.gtktypes; - -/** - * Flags for secret_collection_create(). - */ -public enum SecretCollectionCreateFlags -{ - /** - * no flags - */ - COLLECTION_CREATE_NONE = 0, -} -alias SecretCollectionCreateFlags CollectionCreateFlags; - -/** - * Flags which determine which parts of the #SecretCollection proxy are initialized. - */ -public enum SecretCollectionFlags -{ - /** - * no flags - */ - NONE = 0, - /** - * items have or should be loaded - */ - LOAD_ITEMS = 2, -} -alias SecretCollectionFlags CollectionFlags; - -public enum SecretError -{ - PROTOCOL = 1, - IS_LOCKED = 2, - NO_SUCH_OBJECT = 3, - ALREADY_EXISTS = 4, -} -alias SecretError Error; - -/** - * Flags for secret_item_create(). - */ -public enum SecretItemCreateFlags -{ - /** - * no flags - */ - NONE = 0, - /** - * replace an item with the same attributes. - */ - REPLACE = 2, -} -alias SecretItemCreateFlags ItemCreateFlags; - -/** - * Flags which determine which parts of the #SecretItem proxy are initialized. - */ -public enum SecretItemFlags -{ - /** - * no flags - */ - NONE = 0, - /** - * a secret has been (or should be) loaded for #SecretItem - */ - LOAD_SECRET = 2, -} -alias SecretItemFlags ItemFlags; - -/** - * The type of an attribute in a #SecretSchema. Attributes are stored as strings - * in the Secret Service, and the attribute types simply define standard ways - * to store integer and boolean values as strings. - */ -public enum SecretSchemaAttributeType -{ - /** - * a utf-8 string attribute - */ - STRING = 0, - /** - * an integer attribute, stored as a decimal - */ - INTEGER = 1, - /** - * a boolean attribute, stored as 'true' or 'false' - */ - BOOLEAN = 2, -} -alias SecretSchemaAttributeType SchemaAttributeType; - -/** - * Flags for a #SecretSchema definition. - */ -public enum SecretSchemaFlags -{ - /** - * no flags for the schema - */ - NONE = 0, - /** - * don't match the schema name when looking up or - * removing passwords - */ - DONT_MATCH_NAME = 2, -} -alias SecretSchemaFlags SchemaFlags; - -/** - * Various flags to be used with secret_service_search() and secret_service_search_sync(). - */ -public enum SecretSearchFlags -{ - /** - * no flags - */ - NONE = 0, - /** - * all the items matching the search will be returned, instead of just the first one - */ - ALL = 2, - /** - * unlock locked items while searching - */ - UNLOCK = 4, - /** - * while searching load secrets for items that are not locked - */ - LOAD_SECRETS = 8, -} -alias SecretSearchFlags SearchFlags; - -/** - * Flags which determine which parts of the #SecretService proxy are initialized - * during a secret_service_get() or secret_service_open() operation. - */ -public enum SecretServiceFlags -{ - /** - * no flags for initializing the #SecretService - */ - NONE = 0, - /** - * establish a session for transfer of secrets - * while initializing the #SecretService - */ - OPEN_SESSION = 2, - /** - * load collections while initializing the - * #SecretService - */ - LOAD_COLLECTIONS = 4, -} -alias SecretServiceFlags ServiceFlags; - -struct SecretCollection -{ - GDBusProxy parent; - SecretCollectionPrivate* pv; -} - -/** - * The class for #SecretCollection. - */ -struct SecretCollectionClass -{ - /** - * the parent class - */ - GDBusProxyClass parentClass; - void*[8] padding; -} - -struct SecretCollectionPrivate; - -struct SecretItem -{ - GDBusProxy parentInstance; - SecretItemPrivate* pv; -} - -/** - * The class for #SecretItem. - */ -struct SecretItemClass -{ - /** - * the parent class - */ - GDBusProxyClass parentClass; - void*[4] padding; -} - -struct SecretItemPrivate; - -struct SecretPrompt -{ - GDBusProxy parentInstance; - SecretPromptPrivate* pv; -} - -/** - * The class for #SecretPrompt. - */ -struct SecretPromptClass -{ - /** - * the parent class - */ - GDBusProxyClass parentClass; - void*[8] padding; -} - -struct SecretPromptPrivate; - -struct SecretSchema -{ - /** - * the dotted name of the schema - */ - const(char)* name; - /** - * flags for the schema - */ - SecretSchemaFlags flags; - /** - * the attribute names and types of those attributes - */ - SecretSchemaAttribute[32] attributes; - int reserved; - void* reserved1; - void* reserved2; - void* reserved3; - void* reserved4; - void* reserved5; - void* reserved6; - void* reserved7; -} - -/** - * An attribute in a #SecretSchema. - */ -struct SecretSchemaAttribute -{ - /** - * name of the attribute - */ - const(char)* name; - /** - * the type of the attribute - */ - SecretSchemaAttributeType type; -} - -struct SecretService -{ - GDBusProxy parent; - SecretServicePrivate* pv; -} - -/** - * The class for #SecretService. - */ -struct SecretServiceClass -{ - /** - * the parent class - */ - GDBusProxyClass parentClass; - /** - * the #GType of the #SecretCollection objects instantiated - * by the #SecretService proxy - */ - GType collectionGtype; - /** - * the #GType of the #SecretItem objects instantiated by the - * #SecretService proxy - */ - GType itemGtype; - /** - * - * Params: - * self = the secret service - * prompt = the prompt - * cancellable = optional cancellation object - * returnType = the variant type of the prompt result - * Return: %NULL if the prompt was dismissed or an error occurred, - * a variant result if the prompt was successful - * - * Throws: GException on failure. - */ - extern(C) GVariant* function(SecretService* self, SecretPrompt* prompt, GCancellable* cancellable, GVariantType* returnType, GError** err) promptSync; - /** */ - extern(C) void function(SecretService* self, SecretPrompt* prompt, GVariantType* returnType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) promptAsync; - /** - * - * Params: - * self = the secret service - * result = the asynchronous result passed to the callback - * Return: %NULL if the prompt was dismissed or an error occurred, - * a variant result if the prompt was successful - * - * Throws: GException on failure. - */ - extern(C) GVariant* function(SecretService* self, GAsyncResult* result, GError** err) promptFinish; - /** - * - * Params: - * self = the secret service - * Return: the gobject type for collections - */ - extern(C) GType function(SecretService* self) getCollectionGtype; - /** - * - * Params: - * self = the service - * Return: the gobject type for items - */ - extern(C) GType function(SecretService* self) getItemGtype; - void*[14] padding; -} - -struct SecretServicePrivate; - -struct SecretValue;