topbanner_forum
  *

avatar image

Welcome, Guest. Please login or register.
Did you miss your activation email?

Login with username, password and session length
  • Thursday March 28, 2024, 7:15 am
  • Proudly celebrating 15+ years online.
  • Donate now to become a lifetime supporting member of the site and get a non-expiring license key for all of our programs.
  • donate

Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Messages - Tyinsar [ switch to compact view ]

Pages: [1] 2next
1
JGPaiva's GridMove and Ahk Tools / Re: GridMove: Grids Here
« on: December 01, 2023, 12:04 PM »
Well, I had to know so I downloaded Gridmove and tried it. A lot has changed in Windows so some things didn't work as they used to - but the main parts worked. There are a few more items than you asked for but it all seems to work. (Those extra areas could easily be deleted like this:
[Groups]

NumberOfGroups = 12

[1]
; Monitor1 Left 1/2
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/4
TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
TriggerLeft = [Monitor1Left]
TriggerRight = [Monitor1Left] + [Monitor1Width] *1/4
GridTop = [Monitor1Top]
GridBottom = [Monitor1Bottom]
GridLeft = [Monitor1Left]
GridRight = [Monitor1Left] + [Monitor1Width] /2

[2]
; Monitor1 Right 1/2
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/4
TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
TriggerLeft = [Monitor1Left] + [Monitor1Width] *3/4
TriggerRight = [Monitor1Right]
GridTop = [Monitor1Top]
GridBottom = [Monitor1Bottom]
GridLeft = [Monitor1Left] + [Monitor1Width] /2
GridRight = [Monitor1Right]

[3]
; Monitor1 Top Left 1/4
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/4
TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/2
TriggerLeft = [Monitor1Left] + [Monitor1Width] *1/4
TriggerRight = [Monitor1Left] + [Monitor1Width] *1/2
GridTop = [Monitor1Top]
GridBottom = [Monitor1Top] + [Monitor1Height] /2
GridLeft = [Monitor1Left]
GridRight = [Monitor1Left] + [Monitor1Width] /2

[4]
; Monitor1 Top Right 1/4
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/4
TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/2
TriggerLeft = [Monitor1Left] + [Monitor1Width] *1/2
TriggerRight = [Monitor1Left] + [Monitor1Width] *3/4
GridTop = [Monitor1Top]
GridBottom = [Monitor1Top] + [Monitor1Height] /2
GridLeft = [Monitor1Left] + [Monitor1Width] /2
GridRight = [Monitor1Right]

[5]
; Monitor1 Bottom Left 1/4
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/2
TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
TriggerLeft = [Monitor1Left] + [Monitor1Width] *1/4
TriggerRight = [Monitor1Left] + [Monitor1Width] *1/2
GridTop = [Monitor1Top] + [Monitor1Height] /2
GridBottom = [Monitor1Bottom]
GridLeft = [Monitor1Left]
GridRight = [Monitor1Left] + [Monitor1Width] /2

[6]
; Monitor1 Bottom Right 1/4
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/2
TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
TriggerLeft = [Monitor1Left] + [Monitor1Width] *1/2
TriggerRight = [Monitor1Left] + [Monitor1Width] *3/4
GridTop = [Monitor1Top] + [Monitor1Height] *1/2
GridBottom = [Monitor1Bottom]
GridLeft = [Monitor1Left] + [Monitor1Width] /2
GridRight = [Monitor1Right]

[7]
; Monitor2 Left 1/2
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/4
TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
TriggerLeft = [Monitor2Left]
TriggerRight = [Monitor2Left] + [Monitor2Width] *1/4
GridTop = [Monitor2Top]
GridBottom = [Monitor2Bottom]
GridLeft = [Monitor2Left]
GridRight = [Monitor2Left] + [Monitor2Width] /2

[8]
; Monitor2 Right 1/2
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/4
TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
TriggerLeft = [Monitor2Left] + [Monitor2Width] *3/4
TriggerRight = [Monitor2Right]
GridTop = [Monitor2Top]
GridBottom = [Monitor2Bottom]
GridLeft = [Monitor2Left] + [Monitor2Width] /2
GridRight = [Monitor2Right]

[9]
; Monitor2 Top Left 1/4
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/4
TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/2
TriggerLeft = [Monitor2Left] + [Monitor2Width] *1/4
TriggerRight = [Monitor2Left] + [Monitor2Width] *1/2
GridTop = [Monitor2Top]
GridBottom = [Monitor2Top] + [Monitor2Height] /2
GridLeft = [Monitor2Left]
GridRight = [Monitor2Left] + [Monitor2Width] /2

[10]
; Monitor2 Top Right 1/4
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/4
TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/2
TriggerLeft = [Monitor2Left] + [Monitor2Width] *1/2
TriggerRight = [Monitor2Left] + [Monitor2Width] *3/4
GridTop = [Monitor2Top]
GridBottom = [Monitor2Top] + [Monitor2Height] /2
GridLeft = [Monitor2Left] + [Monitor2Width] /2
GridRight = [Monitor2Right]

[11]
; Monitor2 Bottom Left 1/4
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/2
TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
TriggerLeft = [Monitor2Left] + [Monitor2Width] *1/4
TriggerRight = [Monitor2Left] + [Monitor2Width] *1/2
GridTop = [Monitor2Top] + [Monitor2Height] /2
GridBottom = [Monitor2Bottom]
GridLeft = [Monitor2Left]
GridRight = [Monitor2Left] + [Monitor2Width] /2

[12]
; Monitor2 Bottom Right 1/4
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/2
TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
TriggerLeft = [Monitor2Left] + [Monitor2Width] *1/2
TriggerRight = [Monitor2Left] + [Monitor2Width] *3/4
GridTop = [Monitor2Top] + [Monitor2Height] *1/2
GridBottom = [Monitor2Bottom]
GridLeft = [Monitor2Left] + [Monitor2Width] /2
GridRight = [Monitor2Right]

OR

You could just use the built in Windows key + Arrow key shortcut (On Windows 10 & 11) for the left and right half screens. Then you would only need the following 8 grids:
[Groups]

NumberOfGroups = 8

[1]
; Monitor1 Top Left 1/4
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/4
TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/2
TriggerLeft = [Monitor1Left] + [Monitor1Width] *1/4
TriggerRight = [Monitor1Left] + [Monitor1Width] *1/2
GridTop = [Monitor1Top]
GridBottom = [Monitor1Top] + [Monitor1Height] /2
GridLeft = [Monitor1Left]
GridRight = [Monitor1Left] + [Monitor1Width] /2

[2]
; Monitor1 Top Right 1/4
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/4
TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/2
TriggerLeft = [Monitor1Left] + [Monitor1Width] *1/2
TriggerRight = [Monitor1Left] + [Monitor1Width] *3/4
GridTop = [Monitor1Top]
GridBottom = [Monitor1Top] + [Monitor1Height] /2
GridLeft = [Monitor1Left] + [Monitor1Width] /2
GridRight = [Monitor1Right]

[3]
; Monitor1 Bottom Left 1/4
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/2
TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
TriggerLeft = [Monitor1Left] + [Monitor1Width] *1/4
TriggerRight = [Monitor1Left] + [Monitor1Width] *1/2
GridTop = [Monitor1Top] + [Monitor1Height] /2
GridBottom = [Monitor1Bottom]
GridLeft = [Monitor1Left]
GridRight = [Monitor1Left] + [Monitor1Width] /2

[4]
; Monitor1 Bottom Right 1/4
TriggerTop = [Monitor1Top] + [Monitor1Height] *1/2
TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
TriggerLeft = [Monitor1Left] + [Monitor1Width] *1/2
TriggerRight = [Monitor1Left] + [Monitor1Width] *3/4
GridTop = [Monitor1Top] + [Monitor1Height] *1/2
GridBottom = [Monitor1Bottom]
GridLeft = [Monitor1Left] + [Monitor1Width] /2
GridRight = [Monitor1Right]

[5]
; Monitor2 Top Left 1/4
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/4
TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/2
TriggerLeft = [Monitor2Left] + [Monitor2Width] *1/4
TriggerRight = [Monitor2Left] + [Monitor2Width] *1/2
GridTop = [Monitor2Top]
GridBottom = [Monitor2Top] + [Monitor2Height] /2
GridLeft = [Monitor2Left]
GridRight = [Monitor2Left] + [Monitor2Width] /2

[6]
; Monitor2 Top Right 1/4
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/4
TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/2
TriggerLeft = [Monitor2Left] + [Monitor2Width] *1/2
TriggerRight = [Monitor2Left] + [Monitor2Width] *3/4
GridTop = [Monitor2Top]
GridBottom = [Monitor2Top] + [Monitor2Height] /2
GridLeft = [Monitor2Left] + [Monitor2Width] /2
GridRight = [Monitor2Right]

[7]
; Monitor2 Bottom Left 1/4
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/2
TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
TriggerLeft = [Monitor2Left] + [Monitor2Width] *1/4
TriggerRight = [Monitor2Left] + [Monitor2Width] *1/2
GridTop = [Monitor2Top] + [Monitor2Height] /2
GridBottom = [Monitor2Bottom]
GridLeft = [Monitor2Left]
GridRight = [Monitor2Left] + [Monitor2Width] /2

[8]
; Monitor2 Bottom Right 1/4
TriggerTop = [Monitor2Top] + [Monitor2Height] *1/2
TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
TriggerLeft = [Monitor2Left] + [Monitor2Width] *1/2
TriggerRight = [Monitor2Left] + [Monitor2Width] *3/4
GridTop = [Monitor2Top] + [Monitor2Height] *1/2
GridBottom = [Monitor2Bottom]
GridLeft = [Monitor2Left] + [Monitor2Width] /2
GridRight = [Monitor2Right]

You might want to adjust the triggers to match the grids but I'll leave that up to you.

2
JGPaiva's GridMove and Ahk Tools / Re: GridMove: Grids Here
« on: November 09, 2023, 05:04 PM »
I cant seem to wrap my head around this.  I'm wanting 2 "simple" layouts.  I have 2 monitors, side by side, 1280x1024.  I'm looking for a 2x2 and a 4x4 configuration, like this:
[ Invalid Attachment ]
Try this:
Code: Text [Select]
  1. [Groups]
  2.  
  3. NumberOfGroups = 22
  4.  
  5. [1]
  6. ; Monitor1 Left 1/2
  7.  TriggerTop    = [Monitor1Top] + [Monitor1Height] *1/4
  8.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
  9.  TriggerLeft   = [Monitor1Left]
  10.  TriggerRight  = [Monitor1Left] + [Monitor1Width] *1/4
  11.   GridTop    = [Monitor1Top]
  12.   GridBottom = [Monitor1Bottom]
  13.   GridLeft   = [Monitor1Left]
  14.   GridRight  = [Monitor1Left] + [Monitor1Width] /2
  15.  
  16. [2]
  17. ; Monitor1 Right 1/2
  18.  TriggerTop    = [Monitor1Top] + [Monitor1Height] *1/4
  19.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
  20.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *3/4
  21.  TriggerRight  = [Monitor1Right]
  22.   GridTop    = [Monitor1Top]
  23.   GridBottom = [Monitor1Bottom]
  24.   GridLeft   = [Monitor1Left] + [Monitor1Width] /2
  25.   GridRight  = [Monitor1Right]
  26.  
  27. [3]
  28. ; Monitor1 Top Left 1/4
  29.  TriggerTop    = [Monitor1Top] + [Monitor1Height] *1/4
  30.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/2
  31.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *1/4
  32.  TriggerRight  = [Monitor1Left] + [Monitor1Width] *1/2
  33.   GridTop    = [Monitor1Top]
  34.   GridBottom = [Monitor1Top] + [Monitor1Height] /2
  35.   GridLeft   = [Monitor1Left]
  36.   GridRight  = [Monitor1Left] + [Monitor1Width] /2
  37.  
  38. [4]
  39. ; Monitor1 Top Right 1/4
  40.  TriggerTop    = [Monitor1Top] + [Monitor1Height] *1/4
  41.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/2
  42.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *1/2
  43.  TriggerRight  = [Monitor1Left] + [Monitor1Width] *3/4
  44.   GridTop    = [Monitor1Top]
  45.   GridBottom = [Monitor1Top] + [Monitor1Height] /2
  46.   GridLeft   = [Monitor1Left] + [Monitor1Width] /2
  47.   GridRight  = [Monitor1Right]
  48.  
  49. [5]
  50. ; Monitor1 Bottom Left 1/4
  51.  TriggerTop    = [Monitor1Top] + [Monitor1Height] *1/2
  52.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
  53.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *1/4
  54.  TriggerRight  = [Monitor1Left] + [Monitor1Width] *1/2
  55.   GridTop    = [Monitor1Top] + [Monitor1Height] /2
  56.   GridBottom = [Monitor1Bottom]
  57.   GridLeft   = [Monitor1Left]
  58.   GridRight  = [Monitor1Left] + [Monitor1Width] /2
  59.  
  60. [6]
  61. ; Monitor1 Bottom Right 1/4
  62.  TriggerTop    = [Monitor1Top] + [Monitor1Height] *1/2
  63.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
  64.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *1/2
  65.  TriggerRight  = [Monitor1Left] + [Monitor1Width] *3/4
  66.   GridTop    = [Monitor1Top] + [Monitor1Height] *1/2
  67.   GridBottom = [Monitor1Bottom]
  68.   GridLeft   = [Monitor1Left] + [Monitor1Width] /2
  69.   GridRight  = [Monitor1Right]
  70.  
  71. [7]
  72. ; Monitor1 Top 1/2
  73.  TriggerTop    = [Monitor1Top]
  74.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/4
  75.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *1/4
  76.  TriggerRight  = [Monitor1Left] + [Monitor1Width] *3/4
  77.   GridTop    = [Monitor1Top]
  78.   GridBottom = [Monitor1Top] + [Monitor1Height] *1/2
  79.   GridLeft   = [Monitor1Left]
  80.   GridRight  = [Monitor1Right]
  81.  
  82. [8]
  83. ; Monitor1 Bottom 1/2
  84.  TriggerTop    = [Monitor1Top] + [Monitor1Height] *3/4
  85.  TriggerBottom = [Monitor1Bottom]
  86.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *1/4
  87.  TriggerRight  = [Monitor1Left] + [Monitor1Width] *3/4
  88.   GridTop    = [Monitor1Top] + [Monitor1Height] *1/2
  89.   GridBottom = [Monitor1Bottom]
  90.   GridLeft   = [Monitor1Left]
  91.   GridRight  = [Monitor1Right]
  92.  
  93. [9]
  94. ; Monitor1 FullScreen
  95.  TriggerTop    = [Monitor1Top]
  96.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/4
  97.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *3/4
  98.  TriggerRight  = [Monitor1Right]
  99.   GridTop    = Maximize
  100.   GridBottom = Maximize
  101.   GridLeft   = Maximize
  102.   GridRight  = Maximize
  103.  
  104. [10]
  105. ; Minimize Window
  106.  TriggerTop    = [Monitor1Top] + [Monitor1Height] *3/4
  107.  TriggerBottom = [Monitor1Bottom]
  108.  TriggerLeft   = [Monitor1Left] + [Monitor1Width] *3/4
  109.  TriggerRight  = [Monitor1Right]
  110.   GridTop       = Run
  111.   GridBottom    = Minimize
  112.   GridLeft      = Plugins\MinimizeWindow.exe
  113.   GridRight     =
  114.  
  115. [11]
  116. ; Restore Window
  117.  TriggerTop    = [Monitor1Top]
  118.  TriggerBottom = [Monitor1Top] + [Monitor1Height] *1/4
  119.  TriggerLeft   = [Monitor1Left]
  120.  TriggerRight  = [Monitor1Left] + [Monitor1Width] *1/4
  121.   GridTop    = Restore
  122.   GridBottom = Restore
  123.   GridLeft   = Restore
  124.   GridRight  = Restore
  125.  
  126. [12]
  127. ; Monitor2 Left 1/2
  128.  TriggerTop    = [Monitor2Top] + [Monitor2Height] *1/4
  129.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
  130.  TriggerLeft   = [Monitor2Left]
  131.  TriggerRight  = [Monitor2Left] + [Monitor2Width] *1/4
  132.   GridTop    = [Monitor2Top]
  133.   GridBottom = [Monitor2Bottom]
  134.   GridLeft   = [Monitor2Left]
  135.   GridRight  = [Monitor2Left] + [Monitor2Width] /2
  136.  
  137. [13]
  138. ; Monitor2 Right 1/2
  139.  TriggerTop    = [Monitor2Top] + [Monitor2Height] *1/4
  140.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
  141.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *3/4
  142.  TriggerRight  = [Monitor2Right]
  143.   GridTop    = [Monitor2Top]
  144.   GridBottom = [Monitor2Bottom]
  145.   GridLeft   = [Monitor2Left] + [Monitor2Width] /2
  146.   GridRight  = [Monitor2Right]
  147.  
  148. [14]
  149. ; Monitor2 Top Left 1/4
  150.  TriggerTop    = [Monitor2Top] + [Monitor2Height] *1/4
  151.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/2
  152.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *1/4
  153.  TriggerRight  = [Monitor2Left] + [Monitor2Width] *1/2
  154.   GridTop    = [Monitor2Top]
  155.   GridBottom = [Monitor2Top] + [Monitor2Height] /2
  156.   GridLeft   = [Monitor2Left]
  157.   GridRight  = [Monitor2Left] + [Monitor2Width] /2
  158.  
  159. [15]
  160. ; Monitor2 Top Right 1/4
  161.  TriggerTop    = [Monitor2Top] + [Monitor2Height] *1/4
  162.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/2
  163.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *1/2
  164.  TriggerRight  = [Monitor2Left] + [Monitor2Width] *3/4
  165.   GridTop    = [Monitor2Top]
  166.   GridBottom = [Monitor2Top] + [Monitor2Height] /2
  167.   GridLeft   = [Monitor2Left] + [Monitor2Width] /2
  168.   GridRight  = [Monitor2Right]
  169.  
  170. [16]
  171. ; Monitor2 Bottom Left 1/4
  172.  TriggerTop    = [Monitor2Top] + [Monitor2Height] *1/2
  173.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
  174.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *1/4
  175.  TriggerRight  = [Monitor2Left] + [Monitor2Width] *1/2
  176.   GridTop    = [Monitor2Top] + [Monitor2Height] /2
  177.   GridBottom = [Monitor2Bottom]
  178.   GridLeft   = [Monitor2Left]
  179.   GridRight  = [Monitor2Left] + [Monitor2Width] /2
  180.  
  181. [17]
  182. ; Monitor2 Bottom Right 1/4
  183.  TriggerTop    = [Monitor2Top] + [Monitor2Height] *1/2
  184.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *3/4
  185.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *1/2
  186.  TriggerRight  = [Monitor2Left] + [Monitor2Width] *3/4
  187.   GridTop    = [Monitor2Top] + [Monitor2Height] *1/2
  188.   GridBottom = [Monitor2Bottom]
  189.   GridLeft   = [Monitor2Left] + [Monitor2Width] /2
  190.   GridRight  = [Monitor2Right]
  191.  
  192. [18]
  193. ; Monitor2 Top 1/2
  194.  TriggerTop    = [Monitor2Top]
  195.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/4
  196.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *1/4
  197.  TriggerRight  = [Monitor2Left] + [Monitor2Width] *3/4
  198.   GridTop    = [Monitor2Top]
  199.   GridBottom = [Monitor2Top] + [Monitor2Height] *1/2
  200.   GridLeft   = [Monitor2Left]
  201.   GridRight  = [Monitor2Right]
  202.  
  203. [19]
  204. ; Monitor2 Bottom 1/2
  205.  TriggerTop    = [Monitor2Top] + [Monitor2Height] *3/4
  206.  TriggerBottom = [Monitor2Bottom]
  207.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *1/4
  208.  TriggerRight  = [Monitor2Left] + [Monitor2Width] *3/4
  209.   GridTop    = [Monitor2Top] + [Monitor2Height] *1/2
  210.   GridBottom = [Monitor2Bottom]
  211.   GridLeft   = [Monitor2Left]
  212.   GridRight  = [Monitor2Right]
  213.  
  214. [20]
  215. ; Monitor2 FullScreen
  216.  TriggerTop    = [Monitor2Top]
  217.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/4
  218.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *3/4
  219.  TriggerRight  = [Monitor2Right]
  220.   GridTop    = Maximize
  221.   GridBottom = Maximize
  222.   GridLeft   = Maximize
  223.   GridRight  = Maximize
  224.  
  225. [21]
  226. ; Minimize Window
  227.  TriggerTop    = [Monitor2Top] + [Monitor2Height] *3/4
  228.  TriggerBottom = [Monitor2Bottom]
  229.  TriggerLeft   = [Monitor2Left] + [Monitor2Width] *3/4
  230.  TriggerRight  = [Monitor2Right]
  231.   GridTop       = Run
  232.   GridBottom    = Minimize
  233.   GridLeft      = Plugins\MinimizeWindow.exe
  234.   GridRight     =
  235.  
  236. [22]
  237. ; Restore Window
  238.  TriggerTop    = [Monitor2Top]
  239.  TriggerBottom = [Monitor2Top] + [Monitor2Height] *1/4
  240.  TriggerLeft   = [Monitor2Left]
  241.  TriggerRight  = [Monitor2Left] + [Monitor2Width] *1/4
  242.   GridTop    = Restore
  243.   GridBottom = Restore
  244.   GridLeft   = Restore
  245.   GridRight  = Restore

Completely untested
Other options added just for fun.
Bottom Left area is a safety / abort operation area

Please let me know if this works.

3
JGPaiva's GridMove and Ahk Tools / Re: GridMove: Grids Here
« on: November 08, 2023, 02:38 PM »
Hello bkeadle.

Honestly, It's been years since I used this software. Having 3 large monitors + the new [Win]+[arrow] shortcuts has pretty much replaced this for me. If I needed more I would probably look into the Windows PowerToys feature called FancyZones.

That said, Have you looked at >>> this tutorial <<< ?

(I'm also surprised that anyone is using 1280x1024 monitors - not that I'm against them, I just seldom see them for sale anymore.)

Anyway, As per my initial point, I copied this (below) from https://www.minitool.com/news/move-window-with-keyboard.html (and I wouldn't be surprised if they copied it from somewhere else)

Snap an App Window

In Windows, there is a feature that allows you to snap the window to the right or left side of the computer screen. When dragging the window to the left or right, it will automatically snap to the side and resize.

Here are two keyboard shortcuts to move window:

    Win + Left Arrow: snap the window to the left
    Win + Right Arrow: snap the window to the right

Besides, there are some other keyboard shortcuts to manipulate the active window:

    Win + Home: minimize all windows except the foreground window
    Win + Up Arrow: maxmize a window
    Win + Down Arrow: minimize the window if the window is not maximized, or else, it restores the window to its original size
    Win + Shift + Up: maximize a window vertically

Move Window to Another Monitor

If you want to move your window between multiple monitors, use these keyboard shortcuts:

    Win + Shift + Left Arrow: move a window to the monitor on the left
    Win + Shift+Right Arrow: move a window to the monitor on the right

IF you really still want to use GridMove try following the tutorial. If you get stuck you could post your attempt here and I may be able to help with that.

4
JGPaiva's GridMove and Ahk Tools / Re: GridMove Grid Making Tutorial
« on: January 27, 2008, 08:54 PM »
Hi all. Sorry for the lack of updates to this  :-[ life has had me quite busy but I do plan to finish this in the near future. I think most of what you need to know is here already but ...

@excogitation: Just like you I wanted a grid making tool and I still wouldn't mind one BUT it sounds like it's difficult to create. Also,I suspect that even if one was made it would be very difficult to create one that would have even half of the flexibility of a manually created file. Like Armando says: "try modifying an existing grid ..." If you need help figuring something out or want a better explanation just ask - that's what forums are for (and what I'm trying to help answer with this tutorial - your questions can help us make this better).  :Thmbsup:

5
JGPaiva's GridMove and Ahk Tools / Re: GridMove: Grids Here
« on: January 03, 2008, 04:30 PM »
Well, having tested the "Good Gridance" ;D & "4x4" grids I'd have to say they're much better than I expected :Thmbsup: - though I still doubt I would want to use them on a daily basis. However, I might use them as examples in the GridMove tutorial if that's OK with you.

Also, they reminded me to put a bit about comment lines into the tutorial (when I get back to that - hopefully this weekend), Thanks.

6
JGPaiva's GridMove and Ahk Tools / Re: GridMove: Grids Here
« on: January 03, 2008, 03:26 PM »
Do you find 100+ zones actually usable? What size monitors are you running? I'm running at a resolution of 3840*2048, have 30 zones, and probably only use half of those on any regular basis.

7
JGPaiva's GridMove and Ahk Tools / Re: GridMove Grid Making Tutorial
« on: January 02, 2008, 08:16 PM »
... But the "manual" is looking good, that's for sure!
:o "manual" makes it sound like a huge, intimidating, book that no guy will ever read. ;D Honestly I'm trying to make this as simple and short as I can.

Good News: my extra monitor came in today, though I'm still waiting for the new graphics card. My plan is to try writing Grid files for four monitors just to see how far I can push this (or should I try 6? :D).

8
JGPaiva's GridMove and Ahk Tools / Re: Feature request for GridMove
« on: January 02, 2008, 09:59 AM »
Since the plan is to keep the window the same size would it matter? - Though I'm not sure I understand the issue. If, after loading GridMove, I manually resize a window or open a new one isn't GridMove aware of that? - otherwise "WindowWidth" & WindowHeight" wouldn't work on those. Still, you're the programmer - if it's too much it's not really a feature I need and there's no sense getting the software bloated.

9
Yeah, I read the warnings but thought I'd give it a shot anyway. If there are any issues I think I can fix them. I'm installing XP 64 very soon anyway.

10
JGPaiva's GridMove and Ahk Tools / Re: GridMove Grid Making Tutorial
« on: January 02, 2008, 09:40 AM »
Maybe even a link on the GridMove home page eh? ;)

Even though I expect it to be fairly straight-forward I'm waiting on my new video card (ordered just the other day) before I tackle the multi-monitor portion since I'm currently using my monitors in span mode. (no sense rearranging my desk until then).

11
... Oh, and disabling NTFS last-access (not last-modify) is also very nice.
:Thmbsup: Thanks muchly for the tip. (I also ended up setting "NtfsDisable8dot3NameCreation" to 1)

12
JGPaiva's GridMove and Ahk Tools / Re: GridMove Grid Making Tutorial
« on: January 01, 2008, 03:17 PM »
Thanks lanux.

13
GridMove Grid Making Tutorial nearing completion. Feedback welcome. (link)

14
JGPaiva's GridMove and Ahk Tools / Re: Feature request for GridMove
« on: December 31, 2007, 02:47 AM »
Edit: I thought I could do it but it did not work - though I think I was close.
This isn't in the scope of gridmove, because gridmove always resises the window.
But this really isn't very hard to do as an ahk app, i'm sure some of the other ahk coders here could easily do it.

Sorry for resurrecting an old thread, especially since I think you already have an answer, but I think GridMove could almost do this.
It could be another feature If this gird worked:

[Groups]

NumberOfGroups = 1

[1]
 TriggerTop    = [Monitor1Top] + [Monitor1Height] /4
 TriggerBottom = [Monitor1Top] + [Monitor1Height] *3/4
 TriggerLeft   = [Monitor1Left] + [Monitor1Width] /4
 TriggerRight  = [Monitor1Left] + [Monitor1Width] *3/4
  GridTop    = [Monitor1Top] + [Monitor1Height] /2 - WindowHeight /2
  GridBottom = [Monitor1Top] + [Monitor1Height] /2 + WindowHeight /2
  GridLeft   = [Monitor1Left] + [Monitor1Width] /2 - WindowWidth /2
  GridRight  = [Monitor1Left] + [Monitor1Width] /2 + WindowWidth /2

The issue as I see it is that GridMove doesn't do math on "WindowWidth" or "WindowHeight". Of course I have no idea how much it would take to make that work. I also don't know how many people would want this feature.

15
For some games span mode can be great and I'm using GridMove :-* to get around the maximizing issue. I'm using 2 TripleHead2Go modules in vertical span mode :D. If drivers for Vista can't support that then, for me at least, Vista is broken :( so it's XP 64 for me.

16
Huh, Vista doesn't support spanning monitors? :huh:

Anyway, I've emailed the tClockEx author and am awaiting a reply. ...


Nope. (link) >:(

I hope the author helps out (tClockEx almost looks like an abandoned project though). Thanks for the work you're doing on this. :Thmbsup:

17
Great timing mouser. I just ordered XP64 (yeah I could have got Vista64 but that doesn't support spanning monitors). I used to use tclockex all the time. Currently I run Windows with the taskbar on the left (where it uses less space) and it shows the date if you give it enough space - but like you I miss the simple flexibility of tclockex.

18
You're most welcome Armando. I hope this helps and please let me know if any (finished) parts are unclear.

I'm trying to be accurate without making this harder to read than it has to be, especially for people that speak English as a second language. I find it hard not to use big words and sentences that are way too complex to be clear. :-[ - but I'm trying.

19
Thanks for the "Sticky"

I also hope others will find this useful.

I also hope I will soon find time to finish this. :-[ (3.5/7 parts now in "beta"  ;D)

Feedback from GridMove users is welcome.

20
Thanks JGPaiva  :)
I know what you mean about typos. Like I said, I plan to work on this a little more next week but today I logged in to check your response and noticed I had made quite a few mistakes. :-[ (I think it took me eight 11 edits  ;D)

21
Tutorial started here: https://www.donation...ex.php?topic=11534.0

Please note that this is just a start but I thought I'd post what I had (so far) to get some feedback from you.

22
JGPaiva's GridMove and Ahk Tools / 7) Additional Notes
« on: December 28, 2007, 12:58 AM »
Reserved

23
You can use the methods above to create separate Grids and Triggers for each monitor. The only thing you need to change for this is the "1" in [Monitor1Top], [Monitor1Bottom], [Monitor1Left], [Monitor1Right], [Monitor1Wdth], [Monitor1height], ... to "2" or "3" or ...

But that's not your only option. With GridMove you can define Triggers on any screen that will move windows to another screen on the system.

(to be completed)

24
JGPaiva's GridMove and Ahk Tools / 5) Special Grid Commands
« on: December 28, 2007, 12:52 AM »
Another cool feature of GridMove is that you can create Triggers that do more than just resize a window. You can create a Trigger just like the ones above but instead of defining a new window size you can have a Trigger:

a) set that window to stay on top of other windows by replacing all Grid locations with "AlwaysOnTop" - like this:
  GridTop   = AlwaysOnTop
  GridBottom= AlwaysOnTop
  GridLeft  = AlwaysOnTop
  GridRight = AlwaysOnTop

Tip: to stop a window from staying on top change it to "AlwaysOnTop" a second time - This should return it to normal.

b) restore the window to it's previous size by replacing all the Grid locations with "Restore" - like this:
  GridTop   = Restore
  GridBottom= Restore
  GridLeft  = Restore
  GridRight = Restore

Tip: I find this doesn't always work as I'd hoped (but I have a short memory span :-[). However, it's great when you resize something like a selection box because sometimes the selection box doesn't get any bigger even though the window does. (that's one of my pet peeves with Windows)

c) maximize a window by replacing all Grid locations with "Maximize" - like this:
  GridTop   = Maximize
  GridBottom= Maximize
  GridLeft  = Maximize
  GridRight = Maximize

d) minimize a window by replacing the Grid locations with:
  GridTop       = Run
  GridBottom    = Minimize
  GridLeft      = Plugins\MinimizeWindow.exe
  GridRight     =

Grid order does not matter but it is important that: GridTop = Run, GridBottom = Minimize, GridLeft = Plugins\MinimizeWindow.exe

e) launch an external program. You'll notice that this last set of commands is different. It requires an external program to minimize the window. This opens up other possibilities to use Triggers to launch other programs. The items that I can think of are things like Skrommel's: RunScreenSaver, MinimOther, Ghoster, TransOther, ... (though I have only tested RunScreenSaver)

If you want to use GridMove to launch external programs use the following Grid Commands:
  GridTop    = Run
  GridBottom = Name to display in Trigger area
  GridLeft   = Program path & name

What value this provides to you I'll have to leave to you to figure out. Perhaps there are other useful plugins still in your mind.

f) maximize a window's height like this:
  GridTop   = [Monitor1Top]
  GridBottom= [Monitor1Bottom]
  GridLeft  = WindowWidth
  GridRight = WindowWidth


g) maximize a window's width like this:
  GridTop   = WindowHeight
  GridBottom= WindowHeight
  GridLeft  = [Monitor1Left]
  GridRight = [Monitor1Right]


The first few (a-d) are easy to use but the last two are tricky. "WindowWidth" keeps the window at it's current width and "WindowHeight" keeps the window at it's current height. The tricky part is that if you are using the mouse to drop the window on the Trigger you also end up moving the window (instead of just resizing the height or width). The problem is if you have a small Trigger, that is not near to where you want the window, the window still resizes but in the wrong place.

There are two ways around this. The easiest is to simply use hotkeys to select the Trigger (by default this is [Win]+[G] then [n] when n= number of the Trigger that resizes the window). The problem with this method is that many of us prefer to use the mouse to select Grids - It's also boring. ;)

The second way to solve this problem is to change our Trigger areas. A Trigger that expands a window's height should run across the width of the screen. A Trigger that expands a window's width should be the full height of the screen. This would allow us to slide a window along the Trigger and place it anywhere on the screen.

Remember back in part one that I said there is another method for defining Grids? Well, the time to explain that way has come. You can also define a Grid edge by using a number of pixels. Specifying a number of pixels is useful for small Grids & Triggers, exact Grid & Trigger sizes, and Triggers along edges. You could define a Trigger across the middle of the screen but I find that the outside edges work best so I'd recommend Triggers like:

  TriggerTop    = [MonitorReal1Top]
  TriggerBottom = [MonitorReal1Top] + 20
  TriggerLeft   = [MonitorReal1Left]
  TriggerRight  = [MonitorReal1Right]

which defines a Trigger along the top of the screen,

  TriggerTop    = [MonitorReal1Bottom] - 20
  TriggerBottom = [MonitorReal1Bottom]
  TriggerLeft   = [MonitorReal1Left]
  TriggerRight  = [MonitorReal1Right]

which defines a Trigger along the bottom of the screen,

  TriggerTop    = [MonitorReal1Top]
  TriggerBottom = [MonitorReal1Bottom]
  TriggerLeft   = [MonitorReal1Left]
  TriggerRight  = [MonitorReal1Left] + 20

which defines a Trigger along the left of the screen, or

  TriggerTop    = [MonitorReal1Top]
  TriggerBottom = [MonitorReal1Bottom]
  TriggerLeft   = [MonitorReal1Right] - 20
  TriggerRight  = [MonitorReal1Right]

which defines a Trigger along the right of the screen.

I picked a 20 pixel wide Trigger in all my examples but the exact number is up to you.

To make these active you must either adjust your other Triggers (which is the preferred method) or put these in the file before the other Triggers (so they get activated first - which is the lazy method).

Reminder: A Trigger that expands a window's height should run across the width of the screen. A Trigger that expands a window's width should be the full height of the screen.

These narrow Triggers can also be useful for things like AlwaysOnTop, Minimize, ...

Tip: As Grids get more complex I find it helpful to have bit of the screen that is Not a Trigger zone - just in case I start to move a window and change my mind.

25
JGPaiva's GridMove and Ahk Tools / 4) Multiple / Overlapping Grids:
« on: December 28, 2007, 12:52 AM »
Sometimes you want more than one way to layout your Grids. Let's take our "slightly more complex 3 part Grid":
    ___ ______
   | 1 |      |
   |---|   3  |
   |_2_|______|

and add another option.
    ___ ______
   |_4_|      |
   |_5_|   3  |
   |_6_|______|

Now we have six Grids but no bigger Trigger zone. The key here is that you can define your Grids just like you normally would BUT your Triggers have to be different. There are a coupe of ways to deal with this:

a) Use Triggers that are close to the Grid areas. I suggest that you make the Triggers for the Grids that you plan to use the most bigger than other Triggers. Here's my recommendation for the file:

I want my Triggers to look like this:
    ____ _____
   |4| 1|     |
   |5|--|  3  |
   |6|_2|_____|


If you look closely you will notice that Trigger area 3 has shrunk and that the Triggers no longer match the Grids - but they don't have to so that's OK.

Tip: When the Triggers no longer match the Grids I like to use the entire monitor as an area for Trigger zones (by adding "Real" to the Triggers - see example below). This gives me more space for Triggers and will really help in the next section: Special Grid Commands.

Here's my test.grid file

[Groups]

NumberOfGroups = 6

[1]
 TriggerTop    = [MonitorReal1Top]
 TriggerBottom = [MonitorReal1Top] + [MonitorReal1Height] /2
 TriggerLeft   = [MonitorReal1Left] + [MonitorReal1Width] *1/6
 TriggerRight  = [MonitorReal1Left] + [MonitorReal1Width] *3/6
  GridTop    = [Monitor1Top]
  GridBottom = [Monitor1Top] + [Monitor1Height] /2
  GridLeft   = [Monitor1Left]
  GridRight  = [Monitor1Left] + [Monitor1Width] /3

[2]
 TriggerTop    = [MonitorReal1Top] + [MonitorReal1Height] /2
 TriggerBottom = [MonitorReal1Bottom]
 TriggerLeft   = [MonitorReal1Left] + [MonitorReal1Width] *1/6
 TriggerRight  = [MonitorReal1Left] + [MonitorReal1Width] *3/6
  GridTop    = [Monitor1Top] + [Monitor1Height] /2
  GridBottom = [Monitor1Bottom]
  GridLeft   = [Monitor1Left]
  GridRight  = [Monitor1Left] + [Monitor1Width] /3

[3]
 TriggerTop    = [MonitorReal1Top]
 TriggerBottom = [MonitorReal1Bottom]
 TriggerLeft   = [MonitorReal1Left] + [MonitorReal1Width] *3/6
 TriggerRight  = [MonitorReal1Right]
  GridTop    = [Monitor1Top]
  GridBottom = [Monitor1Bottom]
  GridLeft   = [Monitor1Left] + [Monitor1Width] /3
  GridRight  = [Monitor1Right]

[4]
 TriggerTop    = [MonitorReal1Top]
 TriggerBottom = [MonitorReal1Top] + [MonitorReal1Height] *1/3
 TriggerLeft   = [MonitorReal1Left]
 TriggerRight  = [MonitorReal1Left] + [MonitorReal1Width] *1/6
  GridTop    = [Monitor1Top]
  GridBottom = [Monitor1Top] + [Monitor1Height] /3
  GridLeft   = [Monitor1Left]
  GridRight  = [Monitor1Left] + [Monitor1Width] /3

[5]
 TriggerTop    = [MonitorReal1Top] + [MonitorReal1Height] *1/3
 TriggerBottom = [MonitorReal1Top] + [MonitorReal1Height] *2/3
 TriggerLeft   = [MonitorReal1Left]
 TriggerRight  = [MonitorReal1Left] + [MonitorReal1Width] *1/6
  GridTop    = [Monitor1Top] + [Monitor1Height] /3
  GridBottom = [Monitor1Top] + [Monitor1Height] *2/3
  GridLeft   = [Monitor1Left]
  GridRight  = [Monitor1Left] + [Monitor1Width] /3

[6]
 TriggerTop    = [MonitorReal1Top] + [MonitorReal1Height] *2/3
 TriggerBottom = [MonitorReal1Bottom]
 TriggerLeft   = [MonitorReal1Left]
 TriggerRight  = [MonitorReal1Left] + [MonitorReal1Width] *1/6
  GridTop    = [Monitor1Top] + [Monitor1Height] *2/3
  GridBottom = [Monitor1Bottom]
  GridLeft   = [Monitor1Left]
  GridRight  = [Monitor1Left] + [Monitor1Width] /3



b) Draw Triggers that look like miniature versions of your planned Grids. Personally I find this more complex to draw but it may suit you. There are also some cases where this is the clearest method. For now I'm going to leave this up to you to figure out - It's not really that hard if you plan it out first. (More on this in Using Multiple Monitors)

Pages: [1] 2next