Welcome Guest.   Make a donation to an author on the site October 01, 2014, 11:30:54 PM  *

Please login or register.
Or did you miss your validation email?


Login with username and password (forgot your password?)
Why not become a lifetime supporting member of the site with a one-time donation of any amount? Your donation entitles you to a ton of additional benefits, including access to exclusive discounts and downloads, the ability to enter monthly free software drawings, and a single non-expiring license key for all of our programs.


You must sign up here before you can post and access some areas of the site. Registration is totally free and confidential.
 
Your Support Funds this Site: View the Supporter Yearbook.
   
  Forum Home Thread Marks Chat! Downloads Search Login Register  
  Show Posts
      View this member's profile 
      donate to someone Donate to this member 
Pages: [1] 2 Next
1  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove Grid Making Tutorial on: January 27, 2008, 08:54:13 PM
Hi all. Sorry for the lack of updates to this  embarassed 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
2  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove: Grids Here on: January 03, 2008, 04:30:52 PM
Well, having tested the "Good Gridance" Grin & "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.
3  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove: Grids Here on: January 03, 2008, 03:26:36 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.
4  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove Grid Making Tutorial on: January 02, 2008, 08:16:50 PM
... But the "manual" is looking good, that's for sure!
ohmy "manual" makes it sound like a huge, intimidating, book that no guy will ever read. Grin 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? cheesy).
5  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: Feature request for GridMove on: January 02, 2008, 09:59:17 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.
6  Main Area and Open Discussion / General Software Discussion / Re: Vista’s ReadyBoost benefits on your Windows XP machine with eBoostr on: January 02, 2008, 09:49:17 AM
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.
7  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove Grid Making Tutorial on: January 02, 2008, 09:40:48 AM
Maybe even a link on the GridMove home page eh? Wink

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).
8  Main Area and Open Discussion / General Software Discussion / Re: Vista’s ReadyBoost benefits on your Windows XP machine with eBoostr on: January 02, 2008, 03:36:05 AM
... 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)
9  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove Grid Making Tutorial on: January 01, 2008, 03:17:50 PM
Thanks lanux.
10  DonationCoder.com Software / Post New Requests Here / Re: IDEA: drag window to edge automatically resizes it on: January 01, 2008, 04:53:37 AM
GridMove Grid Making Tutorial nearing completion. Feedback welcome. (link)
11  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: Feature request for GridMove on: December 31, 2007, 02:47:28 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.
12  Main Area and Open Discussion / General Software Discussion / Re: Windows XP Pro x64 (64-bit) Edition - Favorite Software Compatibility Thread on: December 30, 2007, 10:19:07 PM
For some games span mode can be great and I'm using GridMove Kiss to get around the maximizing issue. I'm using 2 TripleHead2Go modules in vertical span mode cheesy. If drivers for Vista can't support that then, for me at least, Vista is broken Sad so it's XP 64 for me.
13  Main Area and Open Discussion / General Software Discussion / Re: Windows XP Pro x64 (64-bit) Edition - Favorite Software Compatibility Thread on: December 30, 2007, 09:49:55 PM
Huh, Vista doesn't support spanning monitors? huh

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


Nope. (link) Angry

I hope the author helps out (tClockEx almost looks like an abandoned project though). Thanks for the work you're doing on this. Thmbsup
14  Main Area and Open Discussion / General Software Discussion / Re: Windows XP Pro x64 (64-bit) Edition - Favorite Software Compatibility Thread on: December 30, 2007, 07:42:26 PM
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.
15  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove Tutorial (Incomplete & Preliminary) on: December 30, 2007, 02:13:18 AM
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. embarassed - but I'm trying.
16  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove Tutorial (Incomplete & Preliminary) on: December 29, 2007, 03:51:31 PM
Thanks for the "Sticky"

I also hope others will find this useful.

I also hope I will soon find time to finish this. embarassed (3.5/7 parts now in "beta"  Grin)

Feedback from GridMove users is welcome.
17  DonationCoder.com Software / JGPaiva's Ahk Tools / Re: GridMove Tutorial (Incomplete & Preliminary) on: December 28, 2007, 09:31:47 AM
Thanks JGPaiva  smiley
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. embarassed (I think it took me eight 11 edits  Grin)
18  DonationCoder.com Software / Post New Requests Here / Re: IDEA: drag window to edge automatically resizes it on: December 28, 2007, 01:13:51 AM
Tutorial started here: http://www.donationcoder....m/index.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.
19  DonationCoder.com Software / JGPaiva's Ahk Tools / 7) Additional Notes on: December 28, 2007, 12:58:32 AM
Reserved
20  DonationCoder.com Software / JGPaiva's Ahk Tools / 6) Using Multiple Monitors: (incomplete) on: December 28, 2007, 12:52:22 AM
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)
21  DonationCoder.com Software / JGPaiva's Ahk Tools / 5) Special Grid Commands on: December 28, 2007, 12:52:12 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 embarassed). 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. Wink

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.
22  DonationCoder.com Software / JGPaiva's Ahk Tools / 4) Multiple / Overlapping Grids: on: December 28, 2007, 12:52:01 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)
23  DonationCoder.com Software / JGPaiva's Ahk Tools / 3) Creating Your First Grid File: on: December 28, 2007, 12:51:50 AM
If you've followed this far then the next step is Very simple:
Number your grids like this:
   [1]
   TriggerTop    = [Monitor1Top]
   TriggerBottom = [Monitor1Top] + [Monitor1Height] /2
   TriggerLeft   = [Monitor1Left]
   TriggerRight  = [Monitor1Left] + [Monitor1Width] /3

   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Top] + [Monitor1Height] /2
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Left] + [Monitor1Width] /3

   [2]
   TriggerTop    = [Monitor1Top] + [Monitor1Height] /2
   TriggerBottom = [Monitor1Bottom]
   TriggerLeft   = [Monitor1Left]
   TriggerRight  = [Monitor1Left] + [Monitor1Width] /3

   GridTop    = [Monitor1Top] + [Monitor1Height] /2
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Left] + [Monitor1Width] /3

   ...

Now start your file with "[Groups]"

The only extra info your file needs is how many grids you have. This comes right after [Groups]

Tip: You can add comment lines by starting them with a ";" like this:
;comment line

The "slightly more complex 3 part grid" file should look something like this:

[Groups]

NumberOfGroups = 3

[1]
;top left
 TriggerTop    = [Monitor1Top]
 TriggerBottom = [Monitor1Top] + [Monitor1Height] /2
 TriggerLeft   = [Monitor1Left]
 TriggerRight  = [Monitor1Left] + [Monitor1Width] /3
  GridTop    = [Monitor1Top]
  GridBottom = [Monitor1Top] + [Monitor1Height] /2
  GridLeft   = [Monitor1Left]
  GridRight  = [Monitor1Left] + [Monitor1Width] /3

[2]
;bottom left
 TriggerTop    = [Monitor1Top] + [Monitor1Height] /2
 TriggerBottom = [Monitor1Bottom]
 TriggerLeft   = [Monitor1Left]
 TriggerRight  = [Monitor1Left] + [Monitor1Width] /3
  GridTop    = [Monitor1Top] + [Monitor1Height] /2
  GridBottom = [Monitor1Bottom]
  GridLeft   = [Monitor1Left]
  GridRight  = [Monitor1Left] + [Monitor1Width] /3

[3]
;bigger area on right
 TriggerTop    = [Monitor1Top]
 TriggerBottom = [Monitor1Bottom]
 TriggerLeft   = [Monitor1Left] + [Monitor1Width] /3
 TriggerRight  = [Monitor1Right]
  GridTop    = [Monitor1Top]
  GridBottom = [Monitor1Bottom]
  GridLeft   = [Monitor1Left] + [Monitor1Width] /3
  GridRight  = [Monitor1Right]


The actual leading spaces (and space between lines) are unimportant but it's good practice to use them for clarity if you want to edit the file later.

Well, That's your first grid file. "How do I use it?" you ask. Simple:
i) Name the file (Choose a name that describes the grid, I'll use "test") and give it a ".grid" extension. My file will be "test.grid"
ii) Move the new file to your "Grids" directory: This is most likely "C:\Program Files\GridMove\Grids"
iii) If GridMove isn't running then start it. If it is then Left-Click on the tray icon and select "Reload"
iv) Left-Click on the tray icon again and select "Templates" then your new grid file (in my case: "test")
v) Test your grid

Note: If there is an error in the format of the file GridMove will give you an error message and load another file on the list.
24  DonationCoder.com Software / JGPaiva's Ahk Tools / 2) Define Trigger Areas: on: December 28, 2007, 12:51:40 AM
OK, a grid is useless without telling the computer what triggers the grid. What we need next are "Triggers"

The trigger commands are:
  TriggerTop    =
  TriggerBottom =
  TriggerLeft   =
  TriggerRight  =

The good news is that Trigger commands take exactly the same information as Grid commands. (There is no bad news  Grin)

So to make our "slightly more complex 3 part grid" we could start creating our file by inputting:
   [1]
   TriggerTop    = [Monitor1Top]
   TriggerBottom = [Monitor1Height] /2
   TriggerLeft   = [Monitor1Left]
   TriggerRight  = [Monitor1Width] /3

   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Height] /2
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Width] /3

   [2]
   TriggerTop    = [Monitor1Height] /2
   TriggerBottom = [Monitor1Bottom]
   TriggerLeft   = [Monitor1Left]
   TriggerRight  = [Monitor1Width] /3

   GridTop    = [Monitor1Height] /2
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Width] /3

   [3]
   TriggerTop    = [Monitor1Top]
   TriggerBottom = [Monitor1Bottom]
   TriggerLeft   = [Monitor1Width] /3
   TriggerRight  = [Monitor1Right]

   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Width] /3
   GridRight  = [Monitor1Right]

In this example the Triggers match the associated Grids - but they don't have to (this is very important later). For now the important thing to remember is that creating a Trigger area is just like creating a Grid.

Tip: If you overlap Trigger areas the the first one in the file takes precedence in the overlapped area.
25  DonationCoder.com Software / JGPaiva's Ahk Tools / 1) Define Grid Areas: on: December 28, 2007, 12:51:32 AM
a) What is a "Grid"? A Grid is an area that your window will be resized to.

For now just follow along. We can't actually make a grid file until the end of section 3 because first we have to plan.

The first and most important thing to decide is how you want to divide your monitor. You can have simple, non-overlapping, grids or complex setups with several different ways to split your screen. It might even be a good idea to sit down and draw out the grids you want before you read any farther.

Tip: Before you go "all out" and create huge number of ways to divide your screen please think carefully about how many of these you would use daily. Sometimes too many options and too many Triggers will actually slow You down. Start with simple grids then ask yourself how many you really need to keep everything flowing smoothly and quickly.

Let me start by introducing a few terms:
   GridTop    =
   GridBottom =
   GridLeft   =
   GridRight  =
These tell GridMove where the edges of your grids are.
Note: I'm not sure if the order of these matters much. Some grid files go in this order:
   GridTop    =
   GridLeft   =
   GridBottom =
   GridRight  =

But my order (top, bottom, left, right) is the simplest one for my brain so it's the one I'll use in this tutorial.

Here are some edges: to start with:
Tip: the "1" is because these all refer to monitor 1. For monitor 2 replace this with a 2.
   [Monitor1Top]
   [Monitor1Bottom]
   [Monitor1Left]
   [Monitor1Right]
Those are what I call "relative" edges because they account for the taskbar. If your taskbar is set to "Auto-Hide" then this doesn't matter much to you.

However, if you have Auto-Hide off, your taskbar is on the bottom of your screen, and it's 20 pixels high then [Monitor1Bottom] defines a location 20 pixels from the bottom of your screen. If it's on the Left and 100 pixels wide then [Monitor1Left] is 100 pixels from the left. ...

So:
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Right]
makes a window the size of your screen (minus the area taken by the taskbar).

There are also what I will call "absolute" edges.
   [MonitorReal1Top]
   [MonitorReal1Bottom]
   [MonitorReal1Left]
   [MonitorReal1Right]
These define real screen edges no matter where the taskbar is. These are great for 2 monitors in "span" mode or for setting exact screen locations and exact window sizes.

So:
   GridTop    = [MonitorReal1Top]
   GridBottom = [MonitorReal1Bottom]
   GridLeft   = [MonitorReal1Left]
   GridRight  = [MonitorReal1Right]
makes a window the size of your screen and includes the area normally taken by the taskbar.

Tip: I always define grid edges that are also on screen edges as relative (without the "Real") just because I may move or resize the taskbar.

The next set of terms are:
   [Monitor1Height]
   [Monitor1Width]
and
   [MonitorReal1Height]
   [MonitorReal1Width]
What these mean should be obvious but here's an example anyway:

On a monitor running at 1680 x 1050 (most 20" and 22" monitors) [MonitorReal1Width] always = 1680 pixels and [MonitorReal1Height] always = 1050 pixels. However [Monitor1Height] and [Monitor1Width] would account for the taskbar so they may be less.

b) Dividing Your Screen

"OK, I want to split my wide screen down the center. How do I do that?"

The main method, and easiest way, is to use simple math:
Grid 1 (Left Window)
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Left] + 1/2 * [Monitor1Width]

Grid 2 (Right Window)
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left] + 1/2 * [Monitor1Width]
   GridRight  = [Monitor1Right]

(Remember: Multiplication & division get done before addition & subtraction)

Tip: GridMove ignores spaces in math equations but I used them here for clarity. They are optional in your grid files.

Tip: Since I thought that [Monitor1Height] starts at the top & [Monitor1Width] starts at the left so [Monitor1Top] and [Monitor1Left] could be left out - but that has odd results (it gets even worse to leave them out when you have more than one monitor). It's usually best to start with one of those edges.

The grids above work but I don't like the way the formulas look so I'll rewrite those as:
Grid 1 (Left Window)
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Left] + [Monitor1Width] /2
Grid 2 (Right Window)
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left] + [Monitor1Width] /2
   GridRight  = [Monitor1Right]



"OK, How about 3 Parts?"
For that we can use fractions:
Grid 1 (Left Window)
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Left] + 1/3 * [Monitor1Width]

Grid 2 (Center Window)
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left] + 1/3 * [Monitor1Width]
   GridRight  = [Monitor1Left] + 2/3 * [Monitor1Width]

Grid 3 (Right Window)
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left] + 2/3 * [Monitor1Width]
   GridRight  = [Monitor1Right]

Tip: "*1/3" also can be simplified to "/3" and is perhaps easier to read that way/

Tip: The math component seems quite flexible. and you can also use fractions, decimals, and percentages. This means that:
   GridLeft   = [Monitor1Left] + [Monitor1Width] /2
is the same as
   GridLeft   = [Monitor1Left] + [Monitor1Width] * 1/2
and
   GridLeft   = [Monitor1Left] + [Monitor1Width] *.5
and
   GridLeft   = [Monitor1Left] + [Monitor1Width] * 50%

I tend to think in fractions so that's what I'll use in my examples. Feel free to convert this to the style that makes the most sense to you.


Another great great thing about GridMove is that you can mix different grid sizes so...
Let's try a slightly more complex 3 part grid:
   [1]
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Top] + [Monitor1Height] /2
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Left] + [Monitor1Width] /3

   [2]
   GridTop    = [Monitor1Top] + [Monitor1Height] /2
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left]
   GridRight  = [Monitor1Left] + [Monitor1Width] /3

   [3]
   GridTop    = [Monitor1Top]
   GridBottom = [Monitor1Bottom]
   GridLeft   = [Monitor1Left] + [Monitor1Width] /3
   GridRight  = [Monitor1Right]
should make a grid like this:

 ___ ______
| 1 |      |
|___|   3  |
| 2 |      |
|___|______|


There is another method for defining grids but I'll get to that in "Special Grid Commands".

Congratulations! If you got this far and understood it then you've already got Most of what you need to know. 
Pages: [1] 2 Next
DonationCoder.com | About Us
DonationCoder.com Forum | Powered by SMF
[ Page time: 0.076s | Server load: 0.03 ]