Added feature to resize horizontally & apply XY position offset via preferences window sliders

meepak · meepak · commit 9bd15f2df170 · 2026-03-21T20:21:15.000+10:30
diff --git a/ddterm/app/application.js b/ddterm/app/application.js
@@ -339,13 +339,13 @@ export class Application extends Gtk.Application {
             'hide': () => this.#window?.hide(),
             'window-size-dec': () => {
                 if (this.#settings.get_boolean('window-maximize'))
-                    this.#settings.set_double('window-size', 1.0 - SIZE_STEP);
+                    this.#settings.set_double('window-size-y', 1.0 - SIZE_STEP);
                 else
-                    this.#adjust_double_setting('window-size', -SIZE_STEP);
+                    this.#adjust_double_setting('window-size-y', -SIZE_STEP);
             },
             'window-size-inc': () => {
                 if (!this.#settings.get_boolean('window-maximize'))
-                    this.#adjust_double_setting('window-size', SIZE_STEP);
+                    this.#adjust_double_setting('window-size-y', SIZE_STEP);
             },
             'background-opacity-dec': () => {
                 this.#adjust_double_setting('background-opacity', -OPACITY_STEP);
diff --git a/ddterm/pref/positionsize.js b/ddterm/pref/positionsize.js
@@ -280,38 +280,68 @@ export class PositionSizeGroup extends PreferencesGroup {
             },
         });
 
-        const window_size_adjustment = new Gtk.Adjustment({
-            upper: 1,
-            step_increment: 0.01,
-            page_increment: 0.10,
+        this.add_slider({
+            key: 'window-size-x',
+            title: 'Window Width',
+            percent: true,
+            lower: 0,
+            upper: 1
+        });
+
+        this.add_slider({
+            key: 'window-size-y',
+            title: 'Window Height',
+            percent: true,
+            lower: 0,
+            upper: 1
+        });
+
+        this.add_slider({
+            key: 'pos-x-offset',
+            title: 'Horizontal Offset',
+        });
+
+        this.add_slider({
+            key: 'pos-y-offset',
+            title: 'Vertical Offset',
+        });
+    }
+
+    add_slider({ key, title, lower = -0.5, upper = 0.5, step = 0.01, digits = 2, percent = true }) {
+        const adjustment = new Gtk.Adjustment({
+            lower,
+            upper,
+            step_increment: step,
+            page_increment: step * 10,
         });
 
         this.settings.bind(
-            'window-size',
-            window_size_adjustment,
+            key,
+            adjustment,
             'value',
             Gio.SettingsBindFlags.DEFAULT
         );
 
-        const window_size_row = new ScaleRow({
-            adjustment: window_size_adjustment,
-            digits: 2,
-            round_digits: 2,
+        const row = new ScaleRow({
+            adjustment,
+            digits,
+            round_digits: digits,
             visible: true,
-            use_underline: true,
-            title: this.gettext('Window _Size'),
+            title: this.gettext(title),
         });
 
-        const percent_format = new Intl.NumberFormat(undefined, { style: 'percent' });
-        window_size_row.set_format_value_func((_, v) => percent_format.format(v));
+        if (percent) {
+            const percent_format = new Intl.NumberFormat(undefined, { style: 'percent' });
+            row.set_format_value_func((_, v) => percent_format.format(v));
+        }
 
         this.settings.bind_writable(
-            'window-size',
-            window_size_row,
+            key,
+            row,
             'sensitive',
             false
         );
 
-        this.add(window_size_row);
+        this.add(row);
     }
 }
diff --git a/ddterm/shell/geometry.js b/ddterm/shell/geometry.js
@@ -69,8 +69,18 @@ export const WindowGeometry = GObject.registerClass({
             Meta.MaximizeFlags,
             Meta.MaximizeFlags.VERTICAL
         ),
-        'window-size': GObject.ParamSpec.double(
-            'window-size',
+        'window-size-x': GObject.ParamSpec.double(
+            'window-size-x',
+            null,
+            null,
+            GObject.ParamFlags.READWRITE | GObject.ParamFlags.EXPLICIT_NOTIFY,
+            0,
+            1,
+            1
+        ),
+
+        'window-size-y': GObject.ParamSpec.double(
+            'window-size-y',
             null,
             null,
             GObject.ParamFlags.READWRITE | GObject.ParamFlags.EXPLICIT_NOTIFY,
@@ -86,6 +96,24 @@ export const WindowGeometry = GObject.registerClass({
             Meta.Side,
             Meta.Side.TOP
         ),
+        'pos-x-offset': GObject.ParamSpec.double(
+            'pos-x-offset',
+            null,
+            null,
+            GObject.ParamFlags.READWRITE | GObject.ParamFlags.EXPLICIT_NOTIFY,
+            -10000,
+            10000,
+            0
+        ),
+        'pos-y-offset': GObject.ParamSpec.double(
+            'pos-y-offset',
+            null,
+            null,
+            GObject.ParamFlags.READWRITE | GObject.ParamFlags.EXPLICIT_NOTIFY,
+            -10000,
+            10000,
+            0
+        ),
         'window-monitor': GObject.ParamSpec.string(
             'window-monitor',
             null,
@@ -123,7 +151,10 @@ export const WindowGeometry = GObject.registerClass({
             this.#update_workarea.bind(this)
         );
 
-        this.connect('notify::window-size', this.#update_target_rect.bind(this));
+        this.connect('notify::window-size-x', this.#update_target_rect.bind(this));
+        this.connect('notify::window-size-y', this.#update_target_rect.bind(this));
+        this.connect('notify::pos-x-offset', this.#update_target_rect.bind(this));
+        this.connect('notify::pos-y-offset', this.#update_target_rect.bind(this));
         this.connect('notify::window-position', this.#update_window_position.bind(this));
         this.connect('notify::window-monitor', this.update_monitor.bind(this));
         this.connect('notify::window-monitor-connector', this.update_monitor.bind(this));
@@ -139,33 +170,54 @@ export const WindowGeometry = GObject.registerClass({
         }
     }
 
-    static get_target_rect(workarea, monitor_scale, size, window_pos) {
-        const target_rect = workarea.copy();
+    static get_target_rect(workarea, monitor_scale, size_x, size_y, window_pos, pos_x_offset, pos_y_offset) {
+        if (size_x === 1 && size_y === 1 && pos_x_offset === 0 && pos_y_offset === 0)
+            return workarea.copy();
 
-        if (size === 1)
-            return target_rect;
+        const target_rect = workarea.copy();
 
         if (window_pos === Meta.Side.LEFT || window_pos === Meta.Side.RIGHT) {
-            target_rect.width *= size;
-            target_rect.width -= target_rect.width % monitor_scale;
+            target_rect.height *= size_y;
+            target_rect.height -= target_rect.height % monitor_scale;
 
             if (window_pos === Meta.Side.RIGHT)
                 target_rect.x += workarea.width - target_rect.width;
         } else {
-            target_rect.height *= size;
+            target_rect.height *= size_y;
             target_rect.height -= target_rect.height % monitor_scale;
 
+            target_rect.width *= size_x;
+            target_rect.width -= target_rect.width % monitor_scale;
+
+            target_rect.x += Math.floor((workarea.width - target_rect.width) / 2);
+
             if (window_pos === Meta.Side.BOTTOM)
                 target_rect.y += workarea.height - target_rect.height;
         }
 
+        target_rect.x -= pos_x_offset * workarea.width;
+        target_rect.y -= pos_y_offset * workarea.height;
+
+        target_rect.x = Math.min(
+            Math.max(target_rect.x, workarea.x),
+            workarea.x + workarea.width - target_rect.width
+        );
+
+        target_rect.y = Math.min(
+            Math.max(target_rect.y, workarea.y),
+            workarea.y + workarea.height - target_rect.height
+        );
+
         return target_rect;
     }
 
     bind_settings(settings) {
         [
-            'window-size',
+            'window-size-x',
+            'window-size-y',
             'window-position',
+            'pos-x-offset',
+            'pos-y-offset',
             'window-monitor',
             'window-monitor-connector',
         ].forEach(key => {
@@ -355,8 +407,11 @@ export const WindowGeometry = GObject.registerClass({
             const target_rect = WindowGeometry.get_target_rect(
                 this.#workarea,
                 Math.floor(this.#monitor_scale),
-                this.window_size,
-                this.window_position
+                this.window_size_x,
+                this.window_size_y,
+                this.window_position,
+                this.pos_x_offset,
+                this.pos_y_offset,
             );
 
             this.#set_target_rect(target_rect);
diff --git a/ddterm/shell/wm.js b/ddterm/shell/wm.js
@@ -114,7 +114,8 @@ export const WindowManager = GObject.registerClass({
         this.#settings_handlers = Object.entries({
             'changed::window-above': this.#set_window_above.bind(this),
             'changed::window-stick': this.#set_window_stick.bind(this),
-            'changed::window-size': this.#disable_window_maximize_setting.bind(this),
+            'changed::window-size-x': this.#disable_window_maximize_setting.bind(this),
+            'changed::window-size-y': this.#disable_window_maximize_setting.bind(this),
             'changed::window-maximize': this.#set_window_maximized.bind(this),
             'changed::hide-when-focus-lost': this.#setup_hide_when_focus_lost.bind(this),
         }).map(
@@ -565,7 +566,7 @@ export const WindowManager = GObject.registerClass({
             return;
 
         if (MOUSE_RESIZE_GRABS.includes(flags))
-            this.#unmaximize_for_resize(this.geometry.maximize_flag);
+            this.#unmaximize_for_resize(Meta.MaximizeFlags.BOTH);
     }
 
     #update_size_setting_on_grab_end(display, win) {
@@ -578,11 +579,12 @@ export const WindowManager = GObject.registerClass({
         this.logger?.log('Updating size setting on grab end');
 
         const frame_rect = win.get_frame_rect();
-        const size = this.geometry.orientation === Clutter.Orientation.HORIZONTAL
-            ? frame_rect.width / this.geometry.workarea.width
-            : frame_rect.height / this.geometry.workarea.height;
 
-        this.settings.set_double('window-size', Math.min(1.0, size));
+        const size_x = Math.min(1.0, frame_rect.width / this.geometry.workarea.width);
+        const size_y = Math.min(1.0, frame_rect.height / this.geometry.workarea.height);
+
+        this.settings.set_double('window-size-x', size_x);
+        this.settings.set_double('window-size-y', size_y);
     }
 
     #unmaximize_for_resize(flags) {
@@ -595,7 +597,8 @@ export const WindowManager = GObject.registerClass({
 
         // There is a _update_window_geometry() call after successful unmaximize.
         // It must set window size to 100%.
-        this.settings.set_double('window-size', 1.0);
+        this.settings.set_double('window-size-x', 1.0);
+        this.settings.set_double('window-size-y', 1.0);
 
         Main.wm.skipNextEffect(this.#actor);
         this.#set_unmaximize_flags(flags);
diff --git a/schemas/com.github.amezin.ddterm.gschema.xml b/schemas/com.github.amezin.ddterm.gschema.xml
@@ -134,7 +134,11 @@ SPDX-License-Identifier: GPL-3.0-or-later
   </enum>
 
   <schema path="/com/github/amezin/ddterm/" id="com.github.amezin.ddterm">
-    <key name="window-size" type="d">
+    <key name="window-size-x" type="d">
+      <default>1.0</default>
+      <range min="0.0" max="1.0"/>
+    </key>
+    <key name="window-size-y" type="d">
       <default>0.6</default>
       <range min="0.0" max="1.0"/>
     </key>
@@ -144,6 +148,14 @@ SPDX-License-Identifier: GPL-3.0-or-later
     <key name="window-position" enum="com.github.amezin.ddterm.WindowPosition">
       <default>'top'</default>
     </key>
+    <key name="pos-x-offset" type="d">
+      <default>0.0</default>
+      <range min="-10000.0" max="10000.0"/>
+    </key>
+    <key name="pos-y-offset" type="d">
+      <default>0.0</default>
+      <range min="-10000.0" max="10000.0"/>
+    </key>
     <key name="window-monitor" enum="com.github.amezin.ddterm.WindowMonitor">
       <default>'current'</default>
     </key>
