windowstate 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Phil Stewart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+windowstate
+===========
+
+Windowstate is a utility for saving and restoring the sizes and positions of
+application windows on Microsoft Windows systems.
+
+Why?
+----
+
+Windows 7 (and probably Vista) have a tendancy to mess up window positions and
+sizes in certain circumstances, such as when disconnecting and reconnecting
+the primary display. The usual symptom is that once the display is reconnected
+all of the application windows have been shrunk and repositioned to the top-left
+corner of the screen. This can be particularly irritating if you have a large
+number of carefully sized and positioned windows open. So far as I can tell
+there is no universal solution to this problem, so I wrote this program as a
+workaround.
+
+Installation
+------------
+
+If you have a RubyInstaller for Windows installation, then you can install
+the gem from a command prompt in the usual way:
+
+```
+gem install windowstate
+```
+
+Alternatively, you can download the standalone executable from github on
+
+https://github.com/downloads/LichP/windowstate/windowstate.exe
+
+Usage
+-----
+
+Windowstate is a command line application, so you will need to run it from the
+command prompt. To save the current window states:
+
+```
+windowstate save
+```
+
+It is recommended you do this immediately before causing a display disconnect.
+Once your display is reconnected, to restore the previously saved window
+state:
+
+```
+windowstate restore
+```
+
+The saved state is stored as JSON in a file called `windowstate.json`, which is
+save in your user local temp directory by default. You can override this with
+the `--file` option - see `windowstate --help` for details.
+
+Does it Work?
+-------------
+
+Windowstate has not been extensively tested: it works on my system with my
+typical window set, but it might not catch some legitimate application
+windows, and has not been tested in a multi-display environment. If you
+run in to problems, please let me know and/or open an issue on Github.
+
+Contact and Contributing
+------------------------
+
+The homepage for this project is
+
+http://github.com/LichP/windowstate
+
+Any feedback, suggestions, etc are very welcome. If you have bugfixes and/or
+contributions, feel free to fork, branch, and send a pull request.
+
+Enjoy :-)
+
+Phil Stewart, June 2012

data/Rakefile

@@ -0,0 +1,20 @@
+#require 'erb'
+#require './lib/windowstate/version'
+
+#$app_name = 'WindowState'
+$exe_name = 'windowstate'
+#$app_version = ''
+
+task :exe do
+  sh %{ ocra bin/#{$exe_name}.rb --output #{$exe_name}.exe }
+end
+
+#task :installer => :inno_iss_file do
+#  sh %{ ocra applaunch.rb app --output #{$app_name}.exe --chdir-first --no-lzma --innosetup #{$app_name}.iss }
+#end
+
+#task :inno_iss_file do
+#  File.open("#{$app_name}.iss", "w") do |f|
+#    f.write(ERB.new(File.read("template.iss.erb")).result(binding))
+#  end
+#end

data/bin/windowstate.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2012 Phil Stewart
+#
+# License:  BSD - see LICENSE file
+# Homepage: https://github.com/LichP/windowstate
+
+begin
+  require 'windowstate'
+rescue LoadError
+  $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+  require 'windowstate'
+end
+
+require 'trollop'
+require 'tmpdir'
+
+exit if defined?(Ocra)
+
+SUB_COMMANDS = %w(save restore debug)
+
+global_opts = Trollop::options do
+  banner "Save and restore the position and size of application windows"
+  banner ""
+  banner "Usage:"
+  banner ""
+  banner "    #{File.basename(ENV['OCRA_EXECUTABLE'] || $0)} [GLOBAL OPTIONS] COMMAND [COMMAND OPTIONS]"
+  banner ""
+  banner "Commands:"
+  banner ""
+  banner "    save            Save the state of current application windows"
+  banner "    restore         Restore the state of current application windows from an earlier save"
+  banner "    debug           Generate debugging information"
+  banner ""
+  banner "Global options:"
+  banner ""
+
+  opt :file, "File to use to save/restore state",
+      short:   "-f",
+      default: File.join(Dir.tmpdir, "windowstate.json")
+      
+  stop_on SUB_COMMANDS
+end
+
+cmd = ARGV.shift
+
+cmd_opts = case cmd
+  when "save"
+    Trollop::options do
+      opt :stdout, "Write state JSON to stdout instead of to file",
+          short:   "-c",
+          default: false
+    end
+  when "restore"
+    Trollop::options do
+    end
+  when "debug"
+    Trollop::options do
+    end
+  else
+    Trollop::die "unknown subcommand #{cmd.inspect}"
+end
+
+case cmd
+  when 'save'
+    if cmd_opts[:stdout]
+      puts WindowState.get_state_json
+    else
+      WindowState.save(global_opts[:file])
+    end
+  when 'restore'
+    WindowState.restore(global_opts[:file])
+  when 'debug'
+    debug_data = WindowState.debug
+    debug_data.each do |hash|
+      hash.each_pair do |key, value|
+        puts "%s: %s" % [key.to_s, value.inspect]
+      end
+    end
+end

data/lib/windowstate.rb

@@ -0,0 +1,201 @@
+# encoding: iso-8859-1
+#
+# Copyright (c) 2012 Phil Stewart
+#
+# License:  BSD - see LICENSE file
+# Homepage: https://github.com/Lichp/windowstate
+
+require 'json'
+require 'windows/window'
+
+module Windows
+  module Window
+    API.new('SetWindowPlacement', 'LP', 'B', 'user32')
+  end
+end
+
+module WindowState
+  include Windows::Window
+  include Win32
+
+  class WindowPlacement
+    include Windows::Window
+  
+    attr_reader :handle, :data_encoded, :title
+    attr_writer :title
+  
+    def self.get(handle)
+      wp = new(handle)
+      wp.get
+      wp
+    end
+  
+    def self.json_create(o)
+      wp = new(o['data'][0])
+      wp.title = o['data'][1]
+      wp.data  = o['data'][2]
+      wp
+    end
+
+    def initialize(handle)
+      @handle = handle
+    end
+  
+    def get
+      wp_buffer = [44].pack("L") + '\0' * 40
+      title_buffer = "\0" * 200
+
+      GetWindowPlacement(handle, wp_buffer)
+      @data_encoded = wp_buffer
+
+      GetWindowText(handle, title_buffer, 200)
+      @title = title_buffer.strip
+    end
+  
+    def set
+      SetWindowPlacement(handle, data_encoded)
+    end
+    
+    def data
+      data_encoded.unpack("L11")
+    end
+    
+    def data=(array)
+      @data_encoded = array.pack("L11")
+    end
+    
+    def to_json(*a)
+      {
+        'json_class' => self.class.name,
+        'data'       => [handle, title, data]
+      }.to_json(*a)
+    end
+
+    def inspect
+      "#<WindowState::WindowPlacement:0x%08x @handle=%i, @title=\"%s\", data=%s>" % [object_id, handle, title, data]
+    end
+  end
+
+  class WindowInfo
+    include Windows::Window
+    
+    WS_CAPTION      = 0x00C00000
+    WS_CHILD        = 0x40000000
+    WS_CLIPSIBLINGS = 0x04000000
+    WS_DISABLED     = 0x08000000
+    WS_DLGFRAME     = 0x00400000
+    WS_POPUP        = 0x80000000
+    WS_SIZEBOX      = 0x00040000
+    WS_SYSMENU      = 0x00080000
+    WS_VISIBLE      = 0x10000000
+    
+    attr_reader :data_encoded, :handle
+    
+    def self.get(handle)
+      wp = new(handle)
+      wp.get
+      wp
+    end
+    
+    def initialize(handle)
+      @handle = handle
+    end
+    
+    def get
+      buffer = [60].pack("L") + '\0' * 56
+      GetWindowInfo(handle, buffer)
+      @data_encoded = buffer
+    end
+    
+    def data
+      data_encoded.unpack("L14S2")
+    end
+    
+    def style
+      data[9]
+    end
+    
+    def ignorable?
+      style & (WS_DISABLED | WS_CHILD) > 0 
+    end
+    
+    def application_window?
+      mask = (WS_SYSMENU | WS_VISIBLE)
+      (style & mask == mask) && !ignorable?
+    end
+    
+    def data=(array)
+      @data_encoded = array.pack("L14S2")
+    end
+    
+    def to_json(*a)
+      {
+        'json_class' => self.class.name,
+        'data'       => [handle, data]
+      }.to_json(*a)
+    end
+    
+    def inspect
+      "#<WindowState::WindowInfo:0x%08x @handle=%i, data=%s>" % [object_id, handle, data]
+    end
+  end
+
+  @wp_save    = []
+  @debug      = []
+
+  @save_proc = API::Callback.new('LP', 'I') do |handle, param|
+    wp = WindowPlacement.get(handle)
+    wi = WindowInfo.get(handle)
+
+    if wi.application_window?
+      @wp_save << wp
+    end
+    true
+  end
+
+  @debug_proc = API::Callback.new('LP', 'I') do |handle, param|
+    wp = WindowPlacement.get(handle)
+    wi = WindowInfo.get(handle)
+
+    @debug << {:wp => wp, :wi => wi}
+    true
+  end
+
+  class << self
+    include Windows::Window
+    include Win32
+    
+    def get_state
+      EnumWindows(@save_proc, nil)
+    end
+    
+    def get_state_json
+      get_state
+      JSON.generate(@wp_save, object_nl: "\n")
+    end
+    
+    def set_state(wp_array)
+      wp_array.each { |wp| wp.set }
+    end
+    
+    def set_state_json(wp_json)
+      set_state(JSON.parse(wp_json))
+    end
+    
+    def save(filename)
+      File.open(filename, "w") do |dump_file|
+        dump_file.puts get_state_json
+      end
+    end
+
+    def restore(filename)
+      set_state_json(File.read(filename))
+    end
+    
+    def debug
+      EnumWindows(@debug_proc, nil)
+      @debug
+    end
+  end
+end
+  

data/lib/windowstate/version.rb

@@ -0,0 +1,3 @@
+module WindowState
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: windowstate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Phil Stewart
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-10 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: windows-pr
+  requirement: &27383856 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *27383856
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &27383556 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *27383556
+- !ruby/object:Gem::Dependency
+  name: ocra
+  requirement: &27383280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: *27383280
+description: ! "WindowState is a utility for saving and restoring the\n    positions
+  and sizes of your application windows, which is useful for\n    monitor hotplugging
+  when Windows decides to shrink everything and\n    shove it in the top-left corner
+  of your desktop."
+email:
+- phil.stewart@lichp.co.uk
+executables:
+- windowstate.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/windowstate/version.rb
+- lib/windowstate.rb
+- README.md
+- LICENSE
+- Rakefile
+- bin/windowstate.rb
+homepage: http://github.com/lichp/windowstate
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Save and restore window positions and sizes on MS Windows
+test_files: []