GridMove Grid Making Tutorial

[Tyinsar]

Creating Your Own Grids

I made this because I Really appreciate this program and want others to love it as much as I do. The problem with GridMove is that, while it's very powerful when properly set up, it's not easy for everyone to get the most out of it (Unless there is an already perfect grid for them or) they create their own grid for their specific setup.

Tip: You can find GridMove Grid files can be posted here: (Link) (you can even share yours)

I'm going to start this fairly simply with only a single monitor setup but the real power comes in with larger screens and multiple monitors.

Sections:

1) Define Grid Areas:
2) Define Trigger Areas:
3) Creating Your First Grid File:
4) Multiple / Overlapping Grids:
5) Special Grid Commands:
6) Using Multiple Monitors: (I'm still planning)
7) Additional Notes: (I'm still planning)

I know this looks like a lot of information but most of it is examples and if you follow along, taking it step by step, it's quite easy. If all you want is a simple Grid then you might only even need parts 1-3.

This is not all complete & parts are preliminary - (but I think it's a useful start)

I'm also still learning the software just like you may be.
Much of what I've learned was from looking at other Grid files - If I stole an idea from you - Thanks! 
(If you really, really, Really, want credit let me know )

If you have any feedback, would like better explanations, or spot an error, please let me know that too.

Parts 1-5 in beta now Feedback is welcome.

Note: If you appreciate this then send Donation Credits (if you are so inclined) to jgpaiva or to this site's general account. (Making this tutorial is my donation).

[Tyinsar]

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. 

[Tyinsar]

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  )

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.

[Tyinsar]

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.

[Tyinsar]

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)

[Tyinsar]

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.

[Tyinsar]

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)

[Tyinsar]

Reserved

[jgpaiva]

 
I'm dazzled... Fantastic work, Tyinsar, i wouldn't do it better myself

I hope this'll be VERY useful for others and we'll start to see new grids appearing

[edit] typos... story of my life [/edit]

[Tyinsar]

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  )

[Tyinsar]

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"  )

Feedback from GridMove users is welcome.

[Armando]

Thanks ! 
I was just saying to jgpaiva, yesterday, how impatient I was to see that tutorial... 
I'll try to modify a few grids on Monday.

[Tyinsar]

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.

[lanux128]

this is long overdue.. great work, Tyinsar!

[Tyinsar]

Thanks lanux.

[jgpaiva]

Oh man... How this has evolved since the last time i read it!!

Ok, i think it's time for me to remove the "make your own grid" section from the help file and link here instead.. 

[Tyinsar]

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).

[Armando]

still haven't got enough time to play with this. But the "manual" is looking good, that's for sure! Thanks Tyinsar.

[Tyinsar]

... But the "manual" is looking good, that's for sure!

-Armando (January 02, 2008, 11:52 AM)

"manual" makes it sound like a huge, intimidating, book that no guy will ever read. 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? ).

[excogitation]

Since this is somewhat complicated... how about an "edit grid" option within GridMove?

What you would need:
edit mode:
- draggable lines
- show trigger areas
- button to add a rectangle for grid/trigger area
- function to discard/save changes
- ...

[jgpaiva]

hi excogitation!
Welcome to the forum.

Actually, i already made an atempt at a grid-making utility, but unfortunatelly, it became even more complicated than doing it by hand and i dropped it...

This really isn't an easy process, but making a gridcreator quite a complicated project. I intend to do it sometime in the future, but not right now.. The next step is to update the help file to a decent and more complete format.

[Armando]

I just transformed a grid yesterday.
If you try modifying an existing grid and look at the results, it's pretty easy to do. Just a bit of maths-geometry involved... 

[Tyinsar]

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). 

[Armando]

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). 

-Tyinsar (January 27, 2008, 08:54 PM)

Exactly. Starting from an existing grid + using Tyinsar guidelines. 

excogitation : would you like a kind of grid in particular ?

[excogitation]

Haven't been welcomed this nice in a forum for a long time.

Thanks.

The explanation is perfectly fine - you don't even need it if you just look at the existing grids,
the thing is just that I'm soo lazy 

I haven't really thought about what layout exactly I want... I just think if you had an editor
it would be really simple to come up with all sorts of useful grids just by playing with it.

Before I forget to mention it - Thanks, jgpaiva, for this program.
I've liked the concept of Acer's GridVista - but it was just missing the customizable layout
(and I didn't like the extra buttons), and have been looking eversince for a grid
program - took me about a year till I finally stumbled upon GridMove.

btw. I've read that you're in the process of converting the existing hardcoded grids to
.grid files - do you by any chance need help with that?