├── .gitattributes
├── .gitignore
├── CMakeLists.txt
├── LICENSE
├── README.md
├── contrib
    ├── CMakeLists.txt
    ├── archlinux
    │   └── PKGBUILD
    ├── emacs-fancy
    │   ├── mosaic.el
    │   └── xwmos_ebuf_select
    ├── gentoo
    │   └── xwinmosaic-9999.ebuild
    ├── xwinmosaic_open_ebuf
    ├── xwinmosaic_run
    └── xwinmosaic_select_ebuf
├── debian
    ├── changelog
    ├── compat
    ├── control
    ├── copyright
    ├── docs
    └── rules
├── src
    ├── CMakeLists.txt
    ├── main.c
    ├── mosaic_box.c
    ├── mosaic_box.h
    ├── mosaic_search_box.c
    ├── mosaic_search_box.h
    ├── mosaic_window_box.c
    ├── mosaic_window_box.h
    ├── win32_interaction.c
    ├── win32_interaction.h
    ├── x_interaction.c
    └── x_interaction.h
└── xwinmosaic.1


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | text=auto
3 | 
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | build
2 | *~
3 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 2.8)
 2 | project (XWinMosaic C)
 3 | 
 4 | OPTION (WITH_SCRIPTS "Install extra scripts" OFF)
 5 | 
 6 | set (CMAKE_C_FLAGS "-std=c99 -Wall")
 7 | 
 8 | IF(WIN32)
 9 |   add_definitions("-DWIN32")
10 |   set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mwindows")
11 | ENDIF(WIN32)
12 | 
13 | IF(UNIX)
14 |   add_definitions("-DX11")
15 | ENDIF(UNIX)
16 | 
17 | set (CMAKE_C_FLAGS_RELEASE "-O3")
18 | set (CMAKE_C_FLAGS_DEBUG "-g")
19 | 
20 | add_subdirectory (src)
21 | 
22 | if (WITH_SCRIPTS)
23 |   add_subdirectory (contrib)
24 | ENDIF (WITH_SCRIPTS)
25 | 
26 | install (FILES xwinmosaic.1
27 | 	DESTINATION share/man/man1)
28 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2012, Anton Lobashev <soulthreads@linuxoids.net>
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without modification,
 5 | are permitted provided that the following conditions are met:
 6 | 
 7 | 1. Redistributions of source code must retain the above copyright notice, this
 8 | list of conditions and the following disclaimer.
 9 | 
10 | 2. Redistributions in binary form must reproduce the above copyright notice,
11 | this list of conditions and the following disclaimer in the documentation and/or
12 | other materials provided with the distribution.
13 | 
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
15 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
18 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
21 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
23 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | XWinMosaic
 2 | ==========
 3 | 
 4 | X11 window switcher that draws windows list as a colourful mosaic
 5 | ------------------------------------------------------------
 6 | 
 7 | Inspired by [XMonad.Actions.GridSelect](http://xmonad.org/xmonad-docs/xmonad-contrib/XMonad-Actions-GridSelect.html), but written in C + GTK+2, uses nice-looking colours and has some set of helpful features.
 8 | 
 9 | ![xwinmosaic's screenshot](https://www.linux.org.ru/images/591/original.png "Screenshot")
10 | 
11 | Use arrow keys (also `C-n`, `C-p`, `C-f`, `C-b` in default mode, `hjkl` in vim mode) or mouse to navigate through windows.
12 | Start typing to search for required window.
13 | 
14 | Config file is created automatically on a first program run and stored in `~/.config/xwinmosaic/config`.
15 | 
16 | ### Usage:
17 |     Usage:
18 |       xwinmosaic [OPTION...]  - show X11 windows as colour mosaic
19 | 
20 |     Help Options:
21 |       -h, --help                   Show help options
22 |       --help-all                   Show all help options
23 |       --help-gtk                   Show GTK+ Options
24 | 
25 |     Application Options:
26 |       -r, --read-stdin             Read items from stdin (and print selected item to stdout)
27 |       -p, --permissive             Lets search entry text to be used as individual item.
28 |       -t, --format                 Read items from stdin in next format (comma separated):
29 |                                         <desktop_num>, <box_color>, <icon>, <label>, <opt_name>.
30 |                                    Icon can be path to png file or icon name from theme.
31 |                                    Any option, except <label> can be skipped
32 |                                    <icon> should be a path to png file or icon name from theme
33 |                                    Any positive value of <desktop_num> allowed.
34 |                                    <box_color> should be in #nnnnnn format, otherwise it will be skipped.
35 |       -V, --vim-mode               Turn on vim-like navigation (hjkl, search on /)
36 |       -C, --no-colors              Turn off box colorizing
37 |       -I, --no-icons               Turn off showing icons
38 |       -D, --no-desktops            Turn off showing desktop number
39 |       -T, --no-titles              Turn off showing titles
40 |       -S, --screenshot             Get screenshot and set it as a background (for WMs that do not support XShape)
41 |       -P, --at-pointer             Place center of mosaic at pointer position.
42 |       -s, --selected=<N>           Select box number N at spawn. (default: 0)
43 |       -W, --box-width=<int>        Width of the boxes (default: 200)
44 |       -H, --box-height=<int>       Height of the boxes (default: 40)
45 |       -i, --icon-size=<int>        Size of window icons (default: 16)
46 |       -f, --font="font [size]"     Which font to use for displaying widgets. (default: "Sans 10")
47 |       -o, --hue-offset=<int>       Set color hue offset (from 0 to 255)
48 |       -F, --color-file=<file>      Pick colors from file
49 |       --display=DISPLAY            X display to use
50 | 
51 | ### Dependencies:
52 | 
53 | * [EWMH compatible Window Manager](http://en.wikipedia.org/wiki/Extended_Window_Manager_Hints)
54 | * GTK+2
55 | * CMake
56 | 
57 | 
58 | ### Installation:
59 | 
60 | * Debian/Ubuntu: https://launchpad.net/~soulthreads/+archive/xwinmosaic/ (might be old, better build it yourself)
61 | * ArchLinux: https://aur.archlinux.org/packages.php?ID=59660
62 | * Gentoo: https://github.com/funtoo/flora/tree/master/x11-apps/xwinmosaic
63 | * openSUSE (packages for 11.4, 12.1 and Tumbleweed): http://download.opensuse.org/repositories/home:/ZaWertun:/gtk2/
64 | 
65 | Other distributions/for development:
66 | 
67 | 	cd xwinmosaic
68 | 	mkdir build
69 | 	cd build
70 | 	cmake ..         # or cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr ..
71 | 	make
72 | 	./src/xwinmosaic # or sudo make install, if you trust me. :)
73 | 
74 | ### Color file format:
75 | 
76 | 	[colors]
77 | 	# Use xprop to determine window class
78 | 	WindowClass1 = #112233
79 | 	WindowClass2 = #445566
80 | 	# For other windows to use. You can omit that line and it will use standard colorizing scheme.
81 | 	fallback = #778899; #AABBCC; #DDEEFF
82 | 


--------------------------------------------------------------------------------
/contrib/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | install (PROGRAMS xwinmosaic_run
2 | 	          xwinmosaic_select_ebuf
3 | 	          xwinmosaic_open_ebuf
4 | 	 DESTINATION bin)
5 | 


--------------------------------------------------------------------------------
/contrib/archlinux/PKGBUILD:
--------------------------------------------------------------------------------
 1 | # $Id: pkgbuild-mode.el,v 1.23 2007/10/20 16:02:14 juergen Exp $
 2 | # Maintainer: Anton S. Lobashev <soulthreads@linuxoids.net>
 3 | pkgname=xwinmosaic-git
 4 | _gitname=xwinmosaic
 5 | pkgver=v0.4.1.12.g4f4ba2a
 6 | pkgrel=1
 7 | pkgdesc="X11 window switcher with fancy look"
 8 | url="http://github.com/soulthreads/xwinmosaic"
 9 | arch=('i686' 'x86_64')
10 | license=('BSD')
11 | depends=('gtk2')
12 | makedepends=('cmake' 'git')
13 | options=(!libtool strip)
14 | 
15 | source=('git://github.com/soulthreads/xwinmosaic.git')
16 | md5sums=('SKIP')
17 | 
18 | pkgver() {
19 |   cd $_gitname
20 |   git describe --always | sed 's|-|.|g'
21 | }
22 | 
23 | build() {
24 |   cd $_gitname
25 |   cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DWITH_SCRIPTS=ON "$srcdir/$_gitname"
26 |   make || return 1
27 | }
28 | 
29 | package() {
30 |   cd $_gitname
31 |   make DESTDIR="$pkgdir" install
32 | }
33 | 


--------------------------------------------------------------------------------
/contrib/emacs-fancy/mosaic.el:
--------------------------------------------------------------------------------
 1 | (require 'cl)
 2 | 
 3 | (defvar xwm-modes-alist
 4 |       '(("jabber" "im-jabber" "#cfb53b")
 5 |         ("haskell" "text-x-haskell")
 6 |         ("python" "text-x-python")
 7 |         ("sh" "text-x-script")
 8 |         ("c-mode" "text-x-csrc")
 9 |         ("" "text-x-generic")))
10 | 
11 | (defun xwm-buffer-mode-str (buffer-name)
12 |   (format "%s"
13 |           (with-current-buffer buffer-name major-mode)))
14 | 
15 | (defun xwm-mode-icon (name)
16 |   (let ((ic-list
17 |          (cdar (remove-if-not (lambda (ic)
18 |                                 (string-match (car ic) (xwm-buffer-mode-str name)))
19 |                               xwm-modes-alist))))
20 |     (if (and
21 |          (string-match "^\*.*\*$" name)
22 |          (string-match "generic" (first ic-list)))
23 |         '("emacs")
24 |       ic-list)))
25 | 
26 | (defun xwm-valid-buffer-list ()
27 |   (remove-if '(lambda (name) (string= (substring name 0 1) " "))
28 |              (mapcar 'buffer-name (buffer-list))))
29 | 
30 | (defun xwm-list-buffers ()
31 |   (mapconcat  '(lambda (s)
32 |                  (let ((ic-list (xwm-mode-icon s)))
33 |                    (format " , %s,%s,%s,%s"
34 |                            (or (second ic-list) "")
35 |                            (first ic-list)
36 |                            s
37 |                            (xwm-buffer-mode-str s))))
38 |             (xwm-valid-buffer-list)
39 |             "\n"))
40 | 
41 | 


--------------------------------------------------------------------------------
/contrib/emacs-fancy/xwmos_ebuf_select:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | emacs_ls ()
 4 | {
 5 |     emacsclient --eval '(xwm-list-buffers)' | xargs echo -e
 6 | }
 7 | 
 8 | emacs_sw ()
 9 | {
10 |     emacs_ls |awk -F',' '{ print $4 }'| grep -x -F -q -e "$1" && \
11 |         emacsclient --eval "(switch-to-buffer \"$1\")"
12 | }
13 | 
14 | items=$(emacs_ls)
15 | 
16 | sel=$(echo "$items" | grep -v ^$ | xwinmosaic -rt $@)
17 | test -z "$sel" && exit 0
18 | 
19 | emacs_sw "$sel"
20 | 


--------------------------------------------------------------------------------
/contrib/gentoo/xwinmosaic-9999.ebuild:
--------------------------------------------------------------------------------
 1 | # Copyright 1999-2012 Gentoo Foundation
 2 | # Distributed under the terms of the GNU General Public License v2
 3 | # $Header: $
 4 | 
 5 | EAPI=4
 6 | 
 7 | inherit git-2 cmake-utils
 8 | 
 9 | DESCRIPTION="X11 window switcher with fancy look."
10 | HOMEPAGE="http://github.com/soulthreads/xwinmosaic"
11 | SRC_URI=""
12 | 
13 | EGIT_REPO_URI="git://github.com/soulthreads/xwinmosaic.git"
14 | 
15 | LICENSE="BSD-2"
16 | SLOT="0"
17 | KEYWORDS="~x86 ~amd64"
18 | IUSE="debug scripts"
19 | 
20 | RDEPEND="x11-libs/libX11
21 | 	=x11-libs/gtk+-2*"
22 | DEPEND="${RDEPEND}
23 | 	virtual/pkgconfig"
24 | 
25 | DOCS="README.md"
26 | 
27 | src_unpack() {
28 |     git-2_src_unpack
29 | }
30 | 
31 | src_configure() {
32 |     local mycmakeargs=(
33 | 	$(cmake-utils_use_with scripts SCRIPTS)
34 |     )
35 | 
36 |     cmake-utils_src_configure
37 | }
38 | 


--------------------------------------------------------------------------------
/contrib/xwinmosaic_open_ebuf:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | #You can customize icons and color of boxes in function below. Don't
 4 | #forget to do same in xwinmosaic_select_ebuf!
 5 | 
 6 | emacs_ls ()
 7 | {
 8 |     emacsclient --eval \
 9 | 	'(mapconcat (quote (lambda (s) (format ", %s,%s,%s,%s"
10 |                                   (cond
11 |                                    ((string-match "jabber" s) "#cfb53b")
12 |                                    (t ""))
13 |                                   (cond
14 |                                    ((string-match "jabber" s) "im-jabber")
15 |                                    (t "emacs"))
16 |                                   s
17 |                                   (replace-regexp-in-string "-mode" ""
18 |                                         (format "%s" (save-excursion (set-buffer s) major-mode))))))
19 |                   (remove-if (quote (lambda (name) (string= (substring name 0 1) " ")))
20 |                              (mapcar (quote buffer-name) (buffer-list)))
21 |                   "\n")' \
22 |                            | xargs echo -e
23 | }
24 | 
25 | emacs_sw ()
26 | {
27 |     emacs_ls |awk -F',' '{ print $4 }'| grep -x -F -q -e "$1" && \
28 |         emacsclient -c --eval "(switch-to-buffer \"$1\")"
29 | }
30 | 
31 | items=$(emacs_ls)
32 | 
33 | sel=$(echo "$items" | grep -v ^$ | xwinmosaic -rt $@)
34 | test -z "$sel" && exit 0 # 1?
35 | 
36 | emacs_sw "$sel"
37 | 


--------------------------------------------------------------------------------
/contrib/xwinmosaic_run:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | exec `(for x in $(echo $PATH|sed s/:/\ /g); do /bin/ls -1 $x; done) | sort -u | xwinmosaic -rp $@` & exit
4 | 


--------------------------------------------------------------------------------
/contrib/xwinmosaic_select_ebuf:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | #You can customize icons and color of boxes in function below. Don't
 4 | #forget to do same in xwinmosaic_open_ebuf!
 5 | 
 6 | emacs_ls ()
 7 | {
 8 |     emacsclient --eval \
 9 | 	'(mapconcat (quote (lambda (s) (format ", %s,%s,%s,%s"
10 |                                   (cond
11 |                                    ((string-match "jabber" s) "#cfb53b")
12 |                                    (t ""))
13 |                                   (cond
14 |                                    ((string-match "jabber" s) "im-jabber")
15 |                                    (t "emacs"))
16 |                                   s
17 |                                   (replace-regexp-in-string "-mode" ""
18 |                                         (format "%s" (save-excursion (set-buffer s) major-mode))))))
19 |                   (remove-if (quote (lambda (name) (string= (substring name 0 1) " ")))
20 |                              (mapcar (quote buffer-name) (buffer-list)))
21 |                   "\n")' \
22 |                            | xargs echo -e
23 | }
24 | 
25 | emacs_sw ()
26 | {
27 |     emacs_ls |awk -F',' '{ print $4 }'| grep -x -F -q -e "$1" && \
28 |         emacsclient --eval "(switch-to-buffer \"$1\")"
29 | }
30 | 
31 | items=$(emacs_ls)
32 | 
33 | sel=$(echo "$items" | grep -v ^$ | xwinmosaic -rt $@)
34 | test -z "$sel" && exit 0 # 1?
35 | 
36 | emacs_sw "$sel"
37 | 


--------------------------------------------------------------------------------
/debian/changelog:
--------------------------------------------------------------------------------
 1 | xwinmosaic (0.4.1+git20120612-1) precise; urgency=low
 2 | 
 3 |   * Added man page
 4 |   * Various bugfixes
 5 | 
 6 |  -- Anton S. Lobashev <soulthreads@linuxoids.net>  Tue, 12 Jun 2012 22:21:43 +0400
 7 | 
 8 | xwinmosaic (0.4+git20120610-1) precise; urgency=low
 9 | 
10 |   * Much more flexibility for defining items (option -t)
11 |   * Updated emacs scripts with some bells and whistles, more native emacs keys
12 |   * Huge amount of bugfixes
13 | 
14 |  -- Anton S. Lobashev <soulthreads@linuxoids.net>  Sun, 10 Jun 2012 00:11:51 +0400
15 | 
16 | xwinmosaic (0.3.3+git20120609-1) precise; urgency=low
17 | 
18 |   * Ability to use user-defined colors
19 |   * Better behaviour and some pack of bugfixes
20 | 
21 |  -- Anton S. Lobashev <soulthreads@linuxoids.net>  Sat, 09 Jun 2012 02:30:17 +0400
22 | 
23 | xwinmosaic (0.3.3+git20120608-1) precise; urgency=low
24 | 
25 |   * Proper fontconfig support
26 |   * Bugfixes
27 | 
28 |  -- Anton S. Lobashev <soulthreads@linuxoids.net>  Fri, 08 Jun 2012 14:45:40 +0400
29 | 
30 | xwinmosaic (0.3.2+git20120605-1) precise; urgency=low
31 | 
32 |   * Better search widget, improved performance, bugfixes.
33 | 
34 |  -- Anton S. Lobashev <soulthreads@linuxoids.net>  Tue, 05 Jun 2012 23:37:16 +0400
35 | 
36 | xwinmosaic (0.3.1+git20120605-1) precise; urgency=low
37 | 
38 |   * Bugfix release, improved scripts, better multi-monitor support
39 | 
40 |  -- Anton S. Lobashev <soulthreads@linuxoids.net>  Tue, 05 Jun 2012 02:02:18 +0400
41 | 
42 | xwinmosaic (0.3+git20120604-1) precise; urgency=low
43 | 
44 |   * Emacs/vim-like navigation
45 |   * Better widgets placing
46 |   * Ability to place center of mosaic at pointer position
47 |   * Many bugfixes
48 | 
49 |  -- Anton S. Lobashev <soulthreads@linuxoids.net>  Mon, 04 Jun 2012 11:53:00 +0400
50 | 
51 | 
52 | xwinmosaic (0.2+git20120603-1) precise; urgency=low
53 | 
54 |   * Initial release
55 | 
56 |  -- Anton S. Lobashev <soulthreads@linuxoids.net>  Sun, 03 Jun 2012 12:41:31 +0400
57 | 


--------------------------------------------------------------------------------
/debian/compat:
--------------------------------------------------------------------------------
1 | 8
2 | 


--------------------------------------------------------------------------------
/debian/control:
--------------------------------------------------------------------------------
 1 | Source: xwinmosaic
 2 | Section: x11
 3 | Priority: extra
 4 | Maintainer: Anton S. Lobashev <soulthreads@linuxoids.net>
 5 | Build-Depends: debhelper (>= 8.0.0), cmake, libx11-dev, libglib2.0-0, libgtk2.0-dev
 6 | Standards-Version: 3.9.2
 7 | Homepage: http://github.com/soulthreads/xwinmosaic
 8 | #Vcs-Git: git://git.debian.org/collab-maint/xwinmosaic.git
 9 | #Vcs-Browser: http://git.debian.org/?p=collab-maint/xwinmosaic.git;a=summary
10 | 
11 | Package: xwinmosaic
12 | Architecture: any
13 | Depends: ${shlibs:Depends}, ${misc:Depends}
14 | Description: X11 window switcher with fancy look
15 |  X11 window switcher that draws windows list as colour mosaic.
16 |  Inspired by XMonad.Actions.GridSelect, but written in C + GTK+2,
17 |  uses nice-looking colours and has some set of helpful features.
18 | 


--------------------------------------------------------------------------------
/debian/copyright:
--------------------------------------------------------------------------------
 1 | Format: http://dep.debian.net/deps/dep5
 2 | Upstream-Name: xwinmosaic
 3 | Source: https://github.com/soulthreads/xwinmosaic
 4 | 
 5 | Files: *
 6 | Copyright: 2012 Anton S. Lobashev <soulthread@linuxoids.net>
 7 | License: BSD-2-clause
 8 |  All rights reserved.
 9 |  
10 |  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
11 |  
12 |  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
13 |  
14 |  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
15 |  
16 |  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
17 | 


--------------------------------------------------------------------------------
/debian/docs:
--------------------------------------------------------------------------------
1 | README.md
2 | 


--------------------------------------------------------------------------------
/debian/rules:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/make -f
 2 | # -*- makefile -*-
 3 | # Sample debian/rules that uses debhelper.
 4 | # This file was originally written by Joey Hess and Craig Small.
 5 | # As a special exception, when this file is copied by dh-make into a
 6 | # dh-make output file, you may use that output file without restriction.
 7 | # This special exception was added by Craig Small in version 0.37 of dh-make.
 8 | 
 9 | # Uncomment this to turn on verbose mode.
10 | #export DH_VERBOSE=1
11 | 
12 | %:
13 | 	dh $@ 
14 | 
15 | override_dh_auto_configure:
16 | 	dh_auto_configure -- -DWITH_SCRIPTS=ON
17 | 


--------------------------------------------------------------------------------
/src/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | find_package (PkgConfig)
 2 | 
 3 | IF(UNIX)
 4 |   pkg_check_modules (DEPS REQUIRED gtk+-2.0 x11)
 5 | ENDIF(UNIX)
 6 | 
 7 | IF(WIN32)
 8 |   pkg_check_modules (DEPS REQUIRED gtk+-2.0)
 9 | ENDIF(WIN32)
10 | 
11 | set (CFLAGS ${DEPS_CFLAGS}
12 |     	    ${DEPS_CFLAGS_OTHER})
13 | set (LIB_PATHS ${DEPS_LIBRARY_DIRS})
14 | link_directories (${LIB_PATHS})
15 | add_definitions (${CFLAGS})
16 | 
17 | IF(UNIX)
18 |   add_executable (xwinmosaic x_interaction.c mosaic_box.c mosaic_window_box.c mosaic_search_box.c main.c)
19 | ENDIF(UNIX)
20 | 
21 | IF(WIN32)
22 |   add_executable (xwinmosaic win32_interaction.c mosaic_box.c mosaic_window_box.c mosaic_search_box.c main.c)
23 | ENDIF(WIN32)
24 | 
25 | target_link_libraries (xwinmosaic ${DEPS_LIBRARIES})
26 | 
27 | install (TARGETS xwinmosaic
28 | 	RUNTIME DESTINATION bin)
29 | 


--------------------------------------------------------------------------------
/src/main.c:
--------------------------------------------------------------------------------
   1 | /* Copyright (c) 2012, Anton S. Lobashev
   2 |  * main.c - main program file
   3 |  */
   4 | 
   5 | #include <stdio.h>
   6 | #include <stdlib.h>
   7 | #include <inttypes.h>
   8 | #include <string.h>
   9 | #include <gtk/gtk.h>
  10 | #include <gdk/gdkkeysyms.h>
  11 | 
  12 | #ifdef X11
  13 | #include <X11/Xlib.h>
  14 | #include <gdk/gdkx.h>
  15 | #include "x_interaction.h"
  16 | #endif
  17 | 
  18 | #ifdef WIN32
  19 | #include <gdk/gdkwin32.h>
  20 | #include "win32_interaction.h"
  21 | #endif
  22 | 
  23 | #include "mosaic_window_box.h"
  24 | #include "mosaic_search_box.h"
  25 | 
  26 | static GtkWidget *window;
  27 | static Window myown_window;
  28 | static Window *active_window; // For displaying it first in windows list.
  29 | static Window *wins;
  30 | static gchar **in_items; // If we read from stdin.
  31 | static int wsize = 0;
  32 | static GtkWidget **boxes;
  33 | static GtkWidget *layout;
  34 | static GtkWidget *search;
  35 | static GtkWidget **filtered_boxes;
  36 | static int filtered_size;
  37 | static int width, height;
  38 | static GdkDrawable *window_shape_bitmap;
  39 | 
  40 | /* for window mask */
  41 | typedef struct {
  42 |   gint x, y, width, height;
  43 | } rect;
  44 | 
  45 | static rect *box_rects;
  46 | static guint boxes_drawn;
  47 | 
  48 | /* for screenshot mode */
  49 | static gboolean key_pressed;
  50 | 
  51 | static GKeyFile *color_config;
  52 | static gchar **fallback_colors;
  53 | static gsize fallback_size;
  54 | 
  55 | static struct {
  56 |   guint box_width;
  57 |   guint box_height;
  58 |   gboolean colorize;
  59 |   gboolean show_icons;
  60 |   gboolean show_desktop;
  61 |   gboolean show_titles;
  62 |   guint icon_size;
  63 |   gchar *font;
  64 |   gboolean read_stdin;
  65 |   gboolean permissive;
  66 |   gboolean persistent;
  67 |   gboolean format;
  68 |   gboolean screenshot;
  69 |   guchar color_offset;
  70 |   gint screenshot_offset_x;
  71 |   gint screenshot_offset_y;
  72 |   gboolean vim_mode;
  73 |   gboolean at_pointer;
  74 |   gint center_x;
  75 |   gint center_y;
  76 |   gchar *color_file;
  77 |   gint selected;
  78 |   gboolean only_current;
  79 | } options;
  80 | 
  81 | typedef struct {
  82 |   gint desktop;
  83 |   gchar *iconpath;
  84 |   gchar *color;
  85 |   gchar *label;
  86 |   gchar *opt_name;
  87 | } Entry;
  88 | 
  89 | static GOptionEntry entries [] =
  90 | {
  91 |   { "persistent", 'R', 0, G_OPTION_ARG_NONE, &options.persistent,
  92 |     "Make XWinMosaic acts like Alt-Tab switcher", NULL },
  93 |   { "read-stdin", 'r', 0, G_OPTION_ARG_NONE, &options.read_stdin,
  94 |     "Read items from stdin (and print selected item to stdout)", NULL },
  95 |   { "permissive", 'p', 0, G_OPTION_ARG_NONE, &options.permissive,
  96 |     "Lets search entry text to be used as individual item.", NULL},
  97 |   { "format", 't', 0, G_OPTION_ARG_NONE, &options.format,
  98 |     "Read items from stdin in next format: <desktop_num>, <box_color>, <icon>, <label>, <opt-name>.", NULL},
  99 |   { "vim-mode", 'V', 0, G_OPTION_ARG_NONE, &options.vim_mode,
 100 |     "Turn on vim-like navigation (hjkl, search on /)", NULL },
 101 |   { "no-colors", 'C', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &options.colorize,
 102 |     "Turn off box colorizing", NULL },
 103 |   { "no-icons", 'I', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &options.show_icons,
 104 |     "Turn off showing icons", NULL },
 105 |   { "no-desktops", 'D', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &options.show_desktop,
 106 |     "Turn off showing desktop number", NULL },
 107 |     { "no-titles", 'T', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &options.show_titles,
 108 |     "Turn off showing titles", NULL },
 109 |   { "screenshot", 'S', 0, G_OPTION_ARG_NONE, &options.screenshot,
 110 |     "Get screenshot and set it as a background (for WMs that do not support XShape)", NULL },
 111 |   { "at-pointer", 'P', 0, G_OPTION_ARG_NONE, &options.at_pointer,
 112 |     "Place center of mosaic at pointer position.", NULL },
 113 |   { "box-width", 'W', 0, G_OPTION_ARG_INT, &options.box_width,
 114 |     "Width of the boxes (default: 200)", "<int>" },
 115 |   { "selected", 's', 0, G_OPTION_ARG_INT, &options.selected,
 116 |     "Initially selected box", "<int>" },
 117 |   { "box-height", 'H', 0, G_OPTION_ARG_INT, &options.box_height,
 118 |     "Height of the boxes (default: 40)", "<int>" },
 119 |   { "icon-size", 'i', 0, G_OPTION_ARG_INT, &options.icon_size,
 120 |     "Size of window icons (default: 16)", "<int>" },
 121 |   { "font", 'f', 0, G_OPTION_ARG_STRING, &options.font,
 122 |     "Which font to use for displaying widgets. (default: \"Sans 10\")", "\"font [size]\"" },
 123 |   { "hue-offset", 'o', 0, G_OPTION_ARG_INT, &options.color_offset,
 124 |     "Set color hue offset (from 0 to 255)", "<int>" },
 125 |   { "color-file", 'F', 0, G_OPTION_ARG_FILENAME, &options.color_file,
 126 |     "Pick colors from file", "<file>" },
 127 |   { "only-current", 'c', 0, G_OPTION_ARG_NONE, &options.only_current,
 128 |     "Only show windows on the current workspace.", NULL},
 129 |   { NULL }
 130 | };
 131 | 
 132 | static GdkRectangle current_monitor_size ();
 133 | static void draw_mosaic (GtkLayout *where,
 134 | 		  GtkWidget **widgets, int rsize,
 135 | 		  int focus_on,
 136 | 		  int rwidth, int rheight);
 137 | static void on_rect_click (GtkWidget *widget, gpointer data);
 138 | static void update_box_list ();
 139 | static gboolean on_key_press (GtkWidget *widget, GdkEventKey *event, gpointer data);
 140 | #ifdef X11
 141 | static GdkFilterReturn event_filter (XEvent *xevent, GdkEvent *event, gpointer data);
 142 | #endif
 143 | static void refilter (MosaicSearchBox *search_box, gpointer data);
 144 | static void draw_mask (GdkDrawable *bitmap, guint size);
 145 | static void read_stdin ();
 146 | static GdkPixbuf* get_screenshot ();
 147 | static void read_config ();
 148 | static void write_default_config ();
 149 | static void on_focus_change (GtkWidget *widget, GdkEventFocus *event, gpointer data);
 150 | static void read_colors ();
 151 | static gboolean parse_format (Entry *entry, gchar *data);
 152 | void tab_event (gboolean shift);
 153 | 
 154 | int main (int argc, char **argv)
 155 | {
 156 |   gtk_init (&argc, &argv);
 157 | 
 158 |   read_config ();
 159 | 
 160 |   // Read options from command-line arguments.
 161 |   GError *error = NULL;
 162 |   GOptionContext *context;
 163 |   context = g_option_context_new (" - show X11 windows as colour mosaic");
 164 |   g_option_context_add_main_entries (context, entries, NULL);
 165 |   g_option_context_add_group (context, gtk_get_option_group (TRUE));
 166 |   if (!g_option_context_parse (context, &argc, &argv, &error)) {
 167 |     g_printerr ("option parsing failed: %s\n", error->message);
 168 |     exit (1);
 169 |   }
 170 |   g_option_context_free (context);
 171 | 
 172 |   if(options.format && !options.read_stdin) {
 173 |     g_printerr("You must provide option --read-stdin!");
 174 |     exit(1);
 175 |   }
 176 | 
 177 | #ifdef X11
 178 |   atoms_init ();
 179 | #endif
 180 | 
 181 |   if (already_opened ()) {
 182 |     g_printerr ("Another instance of xwinmosaic is opened.\n");
 183 |     exit (1);
 184 |   }
 185 | 
 186 |   if (options.read_stdin) {
 187 |     if(!options.format) {
 188 |       options.show_icons = FALSE;
 189 |       options.show_desktop = FALSE;
 190 |     }
 191 |     read_stdin ();
 192 |   } else {
 193 | #ifdef X11
 194 |     // Checks whether WM supports EWMH specifications.
 195 |     if (!wm_supports_ewmh ()) {
 196 |       GtkWidget *dialog = gtk_message_dialog_new
 197 | 	(NULL,
 198 | 	 GTK_DIALOG_MODAL,
 199 | 	 GTK_MESSAGE_ERROR,
 200 | 	 GTK_BUTTONS_CLOSE,
 201 | 	 "Error: your WM does not support EWMH specifications.");
 202 | 
 203 |       gtk_dialog_run (GTK_DIALOG (dialog));
 204 |       g_signal_connect_swapped (dialog, "response",
 205 | 				G_CALLBACK (gtk_main_quit), NULL);
 206 |       return 1;
 207 |     }
 208 | 
 209 |     active_window = (Window *) property (gdk_x11_get_default_root_xwindow (),
 210 | 					 a_NET_ACTIVE_WINDOW,
 211 | 					 XA_WINDOW,
 212 | 					 NULL);
 213 | #endif
 214 |   }
 215 | 
 216 |   if (options.color_file)
 217 |     read_colors ();
 218 | 
 219 | #ifdef WIN32
 220 |   if (options.persistent) {
 221 | #ifdef DEBUG
 222 |       g_printerr ("Installing Alt-Tab hook");
 223 | #endif
 224 |       install_alt_tab_hook();
 225 |   }
 226 | #endif
 227 | 
 228 |   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 229 |   gtk_window_set_title (GTK_WINDOW (window), "XWinMosaic");
 230 | 
 231 |   GdkRectangle rect = current_monitor_size ();
 232 |   width = rect.width;
 233 |   height = rect.height;
 234 | 
 235 |   if (options.at_pointer) {
 236 |     gdk_display_get_pointer (gdk_display_get_default (), NULL, &options.center_x, &options.center_y, NULL);
 237 | 
 238 |     gint monitors = gdk_screen_get_n_monitors (gdk_screen_get_default ());
 239 |     if (monitors > 1) {
 240 |       guint xm = 0, ym = 0;
 241 |       gint current_monitor = gdk_screen_get_monitor_at_point (gdk_screen_get_default (),
 242 | 							      options.center_x, options.center_y);
 243 |       for (int i = 0; i < current_monitor; i++) {
 244 | 	GdkRectangle mon_rect;
 245 | 	gdk_screen_get_monitor_geometry (gdk_screen_get_default (), i, &mon_rect);
 246 | 	xm += mon_rect.width;
 247 | 	ym += mon_rect.height;
 248 |       }
 249 |       if (xm && ym) {
 250 | 	options.center_x %= xm;
 251 | 	options.center_y %= ym;
 252 |       }
 253 |     }
 254 | 
 255 |     if (options.center_x < options.box_width/2)
 256 |       options.center_x = options.box_width/2 + 1;
 257 |     else if (options.center_x > width - options.box_width/2)
 258 |       options.center_x = width - options.box_width/2 - 1;
 259 |     if (options.center_y < options.box_height/2)
 260 |       options.center_y = options.box_height/2 + 1;
 261 |     else if (options.center_y > height - options.box_height/2)
 262 |       options.center_y = height - options.box_height/2 - 1;
 263 |   } else {
 264 |     options.center_x = width/2;
 265 |     options.center_y = height/2;
 266 |   }
 267 | 
 268 |   gtk_window_set_default_size (GTK_WINDOW (window), width, height);
 269 |   gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
 270 |   gtk_window_set_decorated (GTK_WINDOW (window), 0);
 271 |   gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
 272 |   gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), 1);
 273 |   gtk_window_set_skip_pager_hint (GTK_WINDOW (window), 1);
 274 | /**/
 275 |   gtk_widget_add_events (GTK_WIDGET (window), GDK_FOCUS_CHANGE);
 276 |   g_signal_connect (G_OBJECT (window), "focus-out-event",
 277 |         	    G_CALLBACK (on_focus_change), NULL);
 278 | /**/
 279 |   layout = gtk_layout_new (NULL, NULL);
 280 |   gtk_container_add (GTK_CONTAINER (window), layout);
 281 | 
 282 |   if (options.screenshot) {
 283 |     gtk_window_fullscreen (GTK_WINDOW (window));
 284 | 
 285 |     GdkPixbuf *screenshot;
 286 |     GdkPixmap *background = NULL;
 287 |     GtkStyle *style = NULL;
 288 |     screenshot = get_screenshot ();
 289 | 
 290 |     gdk_pixbuf_render_pixmap_and_mask (screenshot, &background, NULL, 0);
 291 |     style = gtk_style_new ();
 292 |     style->bg_pixmap [0] = background;
 293 | 
 294 |     gtk_widget_set_style (window, style);
 295 |     gtk_widget_set_style (layout, style);
 296 |   }
 297 | 
 298 |   search = mosaic_search_box_new ();
 299 |   mosaic_box_set_font (MOSAIC_BOX (search), options.font);
 300 |   gtk_widget_set_can_focus (search, FALSE);
 301 |   GtkRequisition s_req;
 302 |   gtk_widget_size_request (search, &s_req);
 303 |   gtk_layout_put (GTK_LAYOUT (layout), search,
 304 | 		  (width - s_req.width)/2, height - s_req.height - options.box_height);
 305 |   g_signal_connect (G_OBJECT (search), "changed",
 306 | 		    G_CALLBACK (refilter), NULL);
 307 | 
 308 |   g_signal_connect (G_OBJECT (window), "key-press-event",
 309 | 		    G_CALLBACK (on_key_press), NULL);
 310 |   g_signal_connect_swapped(G_OBJECT (window), "destroy",
 311 |         		   G_CALLBACK(gtk_main_quit), NULL);
 312 | 
 313 |   if (!options.screenshot) {
 314 |     window_shape_bitmap = (GdkDrawable *) gdk_pixmap_new (NULL, width, height, 1);
 315 |     draw_mask (window_shape_bitmap, 0);
 316 |     gtk_widget_shape_combine_mask (window, window_shape_bitmap, 0, 0);
 317 |   }
 318 | 
 319 |   gtk_widget_show_all (window);
 320 |   gtk_widget_hide (search);
 321 |   gtk_window_present (GTK_WINDOW (window));
 322 |   gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
 323 |   
 324 |   if (options.persistent)
 325 |     gtk_widget_hide (window);
 326 | 
 327 |   GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
 328 | #ifdef X11
 329 |   myown_window = GDK_WINDOW_XID (gdk_window);
 330 | 
 331 |   if (!options.read_stdin) {
 332 |     // Get PropertyNotify events from root window.
 333 |     XSelectInput (gdk_x11_get_default_xdisplay (),
 334 | 		  gdk_x11_get_default_root_xwindow (),
 335 | 		  PropertyChangeMask);
 336 |     gdk_window_add_filter (NULL, (GdkFilterFunc) event_filter, NULL);
 337 |   }
 338 | #endif
 339 | #ifdef WIN32
 340 |   myown_window = GDK_WINDOW_HWND (gdk_window);
 341 | #endif
 342 |   update_box_list ();
 343 | 
 344 |   draw_mosaic (GTK_LAYOUT (layout), boxes, wsize,
 345 |                options.selected >= wsize ? 0 : options.selected,
 346 | 	       options.box_width, options.box_height);
 347 | 
 348 | #ifdef X11
 349 |   // Window will be shown on all desktops (and so hidden in windows list)
 350 |   unsigned int desk = 0xFFFFFFFF; // -1
 351 |   XChangeProperty(gdk_x11_get_default_xdisplay (), myown_window, a_NET_WM_DESKTOP, XA_CARDINAL,
 352 | 		  32, PropModeReplace, (unsigned char *)&desk, 1);
 353 | #endif
 354 | 
 355 |   gtk_main ();
 356 | 
 357 | #ifdef X11
 358 |   if (!options.read_stdin)
 359 |     XFree (wins);
 360 | #endif
 361 | 
 362 |   return 0;
 363 | }
 364 | 
 365 | static GdkRectangle current_monitor_size ()
 366 | {
 367 |   // Where is the pointer now?
 368 |   gint x, y;
 369 |   gdk_display_get_pointer (gdk_display_get_default (), NULL, &x, &y, NULL);
 370 |   gint monitor = gdk_screen_get_monitor_at_point (gdk_screen_get_default (), x, y);
 371 |   GdkRectangle rect;
 372 |   gdk_screen_get_monitor_geometry (gdk_screen_get_default (), monitor, &rect);
 373 | 
 374 |   return rect;
 375 | }
 376 | 
 377 | static void draw_mosaic (GtkLayout *where,
 378 | 		  GtkWidget **widgets, int rsize,
 379 | 		  int focus_on,
 380 | 		  int rwidth, int rheight)
 381 | {
 382 |   boxes_drawn = 0;
 383 |   int cur_x = options.center_x - rwidth/2;
 384 |   int cur_y = options.center_y - rheight/2;
 385 |   if (rsize) {
 386 |     int i = 0;
 387 |     int offset = 0;
 388 |     int max_offset = (width*2) / rwidth + (height*2) / rheight;
 389 |     int side = 0;
 390 | 
 391 |     while (i < rsize) {
 392 |       int j = 0;
 393 |       do {
 394 | 	if (i == rsize)
 395 | 	  break;
 396 | 	if (cur_x >= 0 && cur_x+rwidth <= width && cur_y >= 0 && cur_y+rheight <= height) {
 397 | 	  offset = 0;
 398 | 	  if (gtk_widget_get_parent (widgets[i]))
 399 | 	    gtk_layout_move (GTK_LAYOUT (where), widgets[i], cur_x, cur_y);
 400 | 	  else
 401 | 	    gtk_layout_put (GTK_LAYOUT (where), widgets[i], cur_x, cur_y);
 402 | 	  gtk_widget_set_size_request (widgets[i], rwidth, rheight);
 403 | 	  gtk_widget_show (widgets[i]);
 404 | 	  if (!options.screenshot) {
 405 | 	    box_rects[i].x = cur_x;
 406 | 	    box_rects[i].y = cur_y;
 407 | 	    boxes_drawn++;
 408 | 	  }
 409 | 	  i++;
 410 | 	} else {
 411 | 	  offset++;
 412 | 	}
 413 | 	if (side) {
 414 | 	  if (j % (side * 4) < side || j % (side * 4) >= side * 3)
 415 | 	    cur_x += rwidth;
 416 | 	  else
 417 | 	    cur_x -= rwidth;
 418 | 	  if (j % (side * 4) < side * 2)
 419 | 	    cur_y += rheight;
 420 | 	  else
 421 | 	    cur_y -= rheight;
 422 | 	}
 423 | 	j++;
 424 |       } while (j < side * 4);
 425 |       if (offset >= max_offset)
 426 | 	break;
 427 |       side++;
 428 |       cur_x = options.center_x - rwidth/2;
 429 |       cur_y -= rheight;
 430 |     }
 431 |     if (focus_on >= rsize)
 432 |       // If some window was killed and focus was on the last element
 433 |       focus_on = rsize-1;
 434 |     gtk_widget_grab_focus (widgets[focus_on]);
 435 |   }
 436 |   if (!options.screenshot) {
 437 |     draw_mask (window_shape_bitmap, rsize);
 438 |     gtk_widget_shape_combine_mask (window, window_shape_bitmap, 0, 0);
 439 |   }
 440 | }
 441 | 
 442 | static void on_rect_click (GtkWidget *widget, gpointer data)
 443 | {
 444 |   MosaicWindowBox *box = MOSAIC_WINDOW_BOX (widget);
 445 | 
 446 |   if (!options.read_stdin) {
 447 |     gtk_widget_hide (window);
 448 |     switch_to_window (mosaic_window_box_get_xwindow (box));
 449 |   } else {
 450 |     puts (mosaic_window_box_get_name (box));
 451 |   }
 452 | 
 453 |   if (options.persistent) {
 454 |     if (strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search)))) {
 455 |       gtk_widget_hide (search);
 456 |       mosaic_search_box_set_text (MOSAIC_SEARCH_BOX (search), "\0");
 457 |     }
 458 |   } else {
 459 |     gtk_main_quit ();
 460 |   }
 461 | }
 462 | 
 463 | static void update_box_list ()
 464 | {
 465 |   if (!options.read_stdin) {
 466 |     if (wsize) {
 467 |       for (int i = 0; i < wsize; i++) {
 468 | 	gtk_widget_destroy (boxes[i]);
 469 |       }
 470 |       free (boxes);
 471 | #ifdef X11
 472 |       XFree (wins);
 473 | #endif
 474 |     }
 475 |     wins = sorted_windows_list (&myown_window, active_window, &wsize, options.only_current);
 476 | #ifdef X11
 477 |     if (wins) {
 478 |       // Get PropertyNotify events from each relevant window.
 479 |       for (int i = 0; i < wsize; i++) {
 480 | 	XSelectInput (gdk_x11_get_default_xdisplay (),
 481 | 		      wins[i],
 482 | 		      PropertyChangeMask);
 483 |       }
 484 |     }
 485 | #endif
 486 |   }
 487 | 
 488 |   if (!options.screenshot && box_rects) {
 489 |     free (box_rects);
 490 |     box_rects = NULL;
 491 |   }
 492 | 
 493 |   if (wsize) {
 494 |     boxes = (GtkWidget **) malloc (wsize * sizeof (GtkWidget *));
 495 | 
 496 |     if (!options.screenshot) {
 497 |       box_rects = (rect *) calloc (wsize, sizeof (rect));
 498 |       for (int i = 0; i < wsize; i++) {
 499 | 	box_rects[i].width = options.box_width;
 500 | 	box_rects[i].height = options.box_height;
 501 |       }
 502 |     }
 503 | 
 504 |     GError *col_error;
 505 |     Entry entry;
 506 |     for (int i = 0; i < wsize; i++) {
 507 |       if (!options.read_stdin) {
 508 | 	boxes[i] = mosaic_window_box_new_with_xwindow (wins[i]);
 509 | #ifdef X11
 510 | 	mosaic_window_box_set_show_desktop (MOSAIC_WINDOW_BOX (boxes[i]), options.show_desktop);
 511 | #endif
 512 | 	mosaic_window_box_set_show_titles (MOSAIC_WINDOW_BOX (boxes[i]), options.show_titles);
 513 | 	if (options.show_icons)
 514 | 	  mosaic_window_box_setup_icon_from_wm (MOSAIC_WINDOW_BOX(boxes[i]), options.icon_size, options.icon_size);
 515 |       } else {
 516 |         if(!options.format)
 517 |           boxes[i] = mosaic_window_box_new_with_name (in_items[i]);
 518 |         else {
 519 |           if(parse_format(&entry, in_items[i])){
 520 |             boxes[i] = mosaic_window_box_new_with_name(entry.label);
 521 |             if((entry.desktop)>=0) {//g_printerr("Custom background digits not implemented yet\n");
 522 |               mosaic_window_box_set_desktop(MOSAIC_WINDOW_BOX(boxes[i]), entry.desktop-1);
 523 |               mosaic_window_box_set_show_desktop (MOSAIC_WINDOW_BOX(boxes[i]), TRUE);
 524 |             }
 525 |             if(options.show_icons && (entry.iconpath)[0]!='*') {
 526 |               if(strchr(entry.iconpath, '.')) {
 527 |                 mosaic_window_box_setup_icon_from_file(MOSAIC_WINDOW_BOX(boxes[i]), entry.iconpath,
 528 |                                                          options.icon_size, options.icon_size);
 529 |               } else {
 530 |                 mosaic_window_box_setup_icon_from_theme(MOSAIC_WINDOW_BOX(boxes[i]), entry.iconpath,
 531 |                                                         options.icon_size, options.icon_size);
 532 |               }
 533 |             }
 534 |             if(strlen(entry.opt_name)){
 535 |               g_printerr("%s\n", entry.opt_name);
 536 |               mosaic_window_box_set_opt_name(MOSAIC_WINDOW_BOX(boxes[i]), entry.opt_name);
 537 |             }
 538 |           } else {
 539 |             boxes[i] = mosaic_window_box_new_with_name("Parse error");
 540 |           }
 541 |         }
 542 |       }
 543 |       mosaic_box_set_font (MOSAIC_BOX (boxes [i]), options.font);
 544 |       mosaic_window_box_set_colorize (MOSAIC_WINDOW_BOX (boxes[i]), options.colorize);
 545 |       mosaic_window_box_set_color_offset (MOSAIC_WINDOW_BOX (boxes[i]), options.color_offset);
 546 |       if (options.colorize && options.color_file) {
 547 | 	gchar *color = NULL;
 548 | 	if (!options.read_stdin) {
 549 | 	  const gchar *wm_class = mosaic_window_box_get_opt_name (MOSAIC_WINDOW_BOX (boxes[i]));
 550 | 	  gchar *class1 = g_strdup (wm_class);
 551 | 	  gchar *class2 = g_strdup (wm_class+strlen (class1)+1);
 552 | 	  if (g_key_file_has_key (color_config, "colors", class1, &col_error))
 553 | 	    color = g_key_file_get_string (color_config, "colors", class1, &col_error);
 554 | 	  else if (g_key_file_has_key (color_config, "colors", class2, &col_error))
 555 | 	    color = g_key_file_get_string (color_config, "colors", class2, &col_error);
 556 | 	  g_free (class1);
 557 | 	  g_free (class2);
 558 | 	}
 559 | 
 560 | 	if (!color && fallback_size)
 561 | 	  color = g_strdup (fallback_colors [i % fallback_size]);
 562 | 
 563 | 	if (color)
 564 | 	  mosaic_window_box_set_color_from_string (MOSAIC_WINDOW_BOX (boxes[i]), color);
 565 | 
 566 | 	g_free (color);
 567 |       }
 568 |       if(options.format) {
 569 |         if((entry.color)[0]=='#')
 570 |           mosaic_window_box_set_color_from_string(MOSAIC_WINDOW_BOX(boxes[i]), entry.color);
 571 |       }
 572 |       g_signal_connect (G_OBJECT (boxes[i]), "clicked",
 573 | 			G_CALLBACK (on_rect_click), NULL);
 574 |     }
 575 |   }
 576 | }
 577 | 
 578 | static gboolean on_key_press (GtkWidget *widget, GdkEventKey *event, gpointer data)
 579 | {
 580 |   key_pressed = TRUE;
 581 |   switch (event->keyval) {
 582 |   case GDK_Escape:
 583 |     if (strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search)))
 584 | 	|| gtk_widget_get_visible (search)) {
 585 |       gtk_widget_hide (search);
 586 |       mosaic_search_box_set_text (MOSAIC_SEARCH_BOX (search), "\0");
 587 |     } else {
 588 |       if (options.persistent)
 589 |         gtk_widget_hide (window);
 590 |       else
 591 |         gtk_main_quit ();
 592 |     }
 593 |     break;
 594 |   case GDK_Return:
 595 |     if(strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search))) && !filtered_size &&
 596 |        options.read_stdin && options.permissive) {
 597 |       puts (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search)));
 598 |       gtk_main_quit();
 599 |     }
 600 |     break;
 601 |   case GDK_Left:
 602 |   case GDK_Up:
 603 |   case GDK_Right:
 604 |   case GDK_Down:
 605 |     break;
 606 |   case GDK_Tab:
 607 |     tab_event(FALSE);
 608 |     return TRUE;
 609 |   case GDK_ISO_Left_Tab:
 610 |     tab_event(TRUE);
 611 |     return TRUE;
 612 |     break;
 613 |   case GDK_End:
 614 |     if (options.permissive) {
 615 |       MosaicWindowBox* box = MOSAIC_WINDOW_BOX (gtk_window_get_focus (GTK_WINDOW (window)));
 616 |       mosaic_search_box_set_text (MOSAIC_SEARCH_BOX (search), mosaic_window_box_get_name (box));
 617 |       gtk_widget_show (search);
 618 |     }
 619 |     break;
 620 |   case GDK_BackSpace:
 621 |     mosaic_search_box_remove_symbols (MOSAIC_SEARCH_BOX (search), 1);
 622 |     if (!strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search))))
 623 |       if (!options.vim_mode)
 624 | 	gtk_widget_hide (search);
 625 |     break;
 626 |   default:
 627 |   {
 628 |     // Ignore Ctrl key.
 629 |     if (event->state & GDK_CONTROL_MASK) {
 630 |       if (!options.vim_mode) {
 631 | 	switch (event->keyval) {
 632 | 	case GDK_n:
 633 | 	  gtk_widget_child_focus (layout, GTK_DIR_DOWN);
 634 | 	  break;
 635 | 	case GDK_p:
 636 | 	  gtk_widget_child_focus (layout, GTK_DIR_UP);
 637 | 	  break;
 638 | 	case GDK_f:
 639 | 	  gtk_widget_child_focus (layout, GTK_DIR_RIGHT);
 640 | 	  break;
 641 | 	case GDK_b:
 642 | 	  gtk_widget_child_focus (layout, GTK_DIR_LEFT);
 643 | 	  break;
 644 | 	case GDK_m:
 645 | 	  if(strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search))) && !filtered_size &&
 646 | 	     options.read_stdin && options.permissive) {
 647 | 	    puts (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search)));
 648 | 	    gtk_main_quit();
 649 | 	  } else {
 650 | 	    g_signal_emit_by_name (gtk_window_get_focus (GTK_WINDOW (window)), "clicked", NULL);
 651 | 	  }
 652 | 	  break;
 653 | 	case GDK_h:
 654 | 	  mosaic_search_box_remove_symbols (MOSAIC_SEARCH_BOX (search), 1);
 655 | 	  if (!strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search))))
 656 | 	    gtk_widget_hide (search);
 657 | 	  break;
 658 | 	case GDK_w:
 659 | 	  mosaic_search_box_kill_word (MOSAIC_SEARCH_BOX (search));
 660 | 	  if (!strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search))))
 661 | 	    gtk_widget_hide (search);
 662 | 	  break;
 663 | 	case GDK_g:
 664 | 	  if (strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search)))
 665 | 	      || gtk_widget_get_visible (search)) {
 666 | 	    gtk_widget_hide (search);
 667 | 	    mosaic_search_box_set_text (MOSAIC_SEARCH_BOX (search), "\0");
 668 | 	  } else {
 669 | 	    gtk_main_quit ();
 670 | 	  }
 671 | 	  break;
 672 | 	}
 673 |       }
 674 |       return FALSE;
 675 |     }
 676 |     
 677 |     /* if(event->state & GDK_SHIFT_MASK) { */
 678 |     /*   switch(event->keyval) { */
 679 |     /*   case GDK_Tab: */
 680 |     /*     { */
 681 |     /*       g_printerr("Shift-Tab\n"); */
 682 |     /*       tab_event(TRUE); */
 683 |     /*       return TRUE; */
 684 |     /*     } */
 685 |     /*   default: */
 686 |     /*     g_printerr("keyval = %d\n", event->keyval); */
 687 |     /*   } */
 688 |     /* } */
 689 |     
 690 |     if (options.vim_mode && !gtk_widget_get_visible (search)) {
 691 |       switch (event->keyval) {
 692 |       case GDK_h:
 693 | 	gtk_widget_child_focus (layout, GTK_DIR_LEFT);
 694 | 	break;
 695 |       case GDK_j:
 696 | 	gtk_widget_child_focus (layout, GTK_DIR_DOWN);
 697 | 	break;
 698 |       case GDK_k:
 699 | 	gtk_widget_child_focus (layout, GTK_DIR_UP);
 700 | 	break;
 701 |       case GDK_l:
 702 | 	gtk_widget_child_focus (layout, GTK_DIR_RIGHT);
 703 | 	break;
 704 |       case GDK_slash:
 705 | 	gtk_widget_show (search);
 706 | 	g_signal_emit_by_name (G_OBJECT (search), "changed", NULL);
 707 | 	break;
 708 |       }
 709 |       return TRUE;
 710 |     }
 711 | 
 712 |     char *key = event->string;
 713 |     if (strlen(key)) {
 714 |       mosaic_search_box_append_text (MOSAIC_SEARCH_BOX (search), key);
 715 |       int text_length = strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search)));
 716 |       if (text_length)
 717 | 	gtk_widget_show (search);
 718 |       return TRUE;
 719 |     }
 720 |   }
 721 |   }
 722 |   return FALSE;
 723 | }
 724 | 
 725 | #ifdef X11
 726 | static GdkFilterReturn event_filter (XEvent *xevent, GdkEvent *event, gpointer data)
 727 | {
 728 |   if (xevent->type == PropertyNotify) {
 729 |     Atom atom = xevent->xproperty.atom;
 730 |     Window win = xevent->xproperty.window;
 731 |     if (win == gdk_x11_get_default_root_xwindow ()) {
 732 |       if (atom == a_NET_CLIENT_LIST) {
 733 | 	int focus_on = 0;
 734 | 	if (filtered_size && filtered_boxes) {
 735 | 	  for (int i = 0; i < filtered_size; i++)
 736 | 	    if (gtk_widget_is_focus (filtered_boxes [i])) {
 737 | 	      focus_on = i;
 738 | 	      break;
 739 | 	    }
 740 | 	} else {
 741 | 	  for (int i = 0; i < wsize; i++)
 742 | 	    if (gtk_widget_is_focus (boxes [i])) {
 743 | 	      focus_on = i;
 744 | 	      break;
 745 | 	    }
 746 | 	}
 747 | 	update_box_list ();
 748 | 	if (strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search)))) {
 749 | 	  refilter (MOSAIC_SEARCH_BOX (search), NULL);
 750 | 	  draw_mosaic (GTK_LAYOUT (layout), filtered_boxes, filtered_size, focus_on,
 751 | 		       options.box_width, options.box_height);
 752 | 	} else {
 753 | 	  draw_mosaic (GTK_LAYOUT (layout), boxes, wsize, focus_on,
 754 | 		       options.box_width, options.box_height);
 755 | 	}
 756 |       }
 757 |     } else {
 758 |       if (atom == a_WM_NAME || atom == a_NET_WM_NAME || atom == a_NET_WM_VISIBLE_NAME) {
 759 | 	// Search for appropriate widget to change label.
 760 | 	for (int i = 0; i < wsize; i++)
 761 | 	  if (wins [i] == win) {
 762 | 	    mosaic_window_box_update_xwindow_name (MOSAIC_WINDOW_BOX (boxes[i]));
 763 | 	    break;
 764 | 	  }
 765 |       }
 766 |       if (atom == a_NET_WM_ICON && options.show_icons) {
 767 | 	// Search for appropriate widget to update icon.
 768 | 	for (int i = 0; i < wsize; i++)
 769 | 	  if (wins [i] == win) {
 770 | 	    mosaic_window_box_setup_icon_from_wm (MOSAIC_WINDOW_BOX (boxes[i]), options.icon_size, options.icon_size);
 771 | 	    break;
 772 | 	  }
 773 |       }
 774 |     }
 775 |   }
 776 | 
 777 |   return GDK_FILTER_CONTINUE;
 778 | }
 779 | #endif
 780 | 
 781 | static gboolean search_by_letters (const gchar *source, gint s_len, const gchar *letters, gint l_len)
 782 | {
 783 |   gboolean found = FALSE;
 784 |   const gchar *p1 = letters;
 785 |   const gchar *p2 = source;
 786 |   while (p1 < letters + l_len) {
 787 |     gunichar c1 = g_utf8_get_char (p1);
 788 |     found = FALSE;
 789 |     while (p2 < source + s_len) {
 790 |       gunichar c2 = g_utf8_get_char (p2);
 791 |       if (c1 == c2) {
 792 | 	found = TRUE;
 793 | 	p2 = g_utf8_find_next_char (p2, NULL);
 794 | 	break;
 795 |       }
 796 |       p2 = g_utf8_find_next_char (p2, NULL);
 797 |     }
 798 |     if (!found)
 799 |       break;
 800 |     p1 = g_utf8_find_next_char (p1, NULL);
 801 |   }
 802 | 
 803 |   return found;
 804 | }
 805 | 
 806 | static void refilter (MosaicSearchBox *search_box, gpointer data)
 807 | {
 808 |   if (filtered_size) {
 809 |     free (filtered_boxes);
 810 |   }
 811 |   filtered_size = 0;
 812 | 
 813 |   for (int i = 0; i < wsize; i++)
 814 |       gtk_widget_hide (boxes [i]);
 815 | 
 816 |   gchar *search_for = g_utf8_casefold (mosaic_search_box_get_text (search_box), -1);
 817 |   int s_size = strlen (search_for);
 818 |   if (s_size) {
 819 |     filtered_boxes = (GtkWidget **) malloc (wsize * sizeof (GtkWidget *));
 820 | 
 821 |     GtkWidget **priority1 = (GtkWidget **) malloc (wsize * sizeof (GtkWidget *));
 822 |     GtkWidget **priority2 = (GtkWidget **) malloc (wsize * sizeof (GtkWidget *));
 823 |     GtkWidget **priority3 = (GtkWidget **) malloc (wsize * sizeof (GtkWidget *));
 824 |     gint p1size = 0;
 825 |     gint p2size = 0;
 826 |     gint p3size = 0;
 827 | 
 828 |     for (int i = 0; i < wsize; i++) {
 829 |       gchar *wname_cmp = NULL;
 830 |       gchar *opt_name1_cmp = NULL;
 831 |       gchar *opt_name2_cmp = NULL;
 832 |       int wn_size = 0;
 833 |       int op1_size = 0;
 834 |       int op2_size = 0;
 835 | 
 836 |       wname_cmp = g_utf8_casefold (mosaic_window_box_get_name (MOSAIC_WINDOW_BOX (boxes[i])), -1);
 837 |       wn_size = strlen (wname_cmp);
 838 |       const gchar *opt_name = mosaic_window_box_get_opt_name (MOSAIC_WINDOW_BOX (boxes[i]));
 839 |       if (opt_name) {
 840 | 	opt_name1_cmp = g_utf8_casefold (opt_name, -1);
 841 | 	op1_size = strlen (opt_name1_cmp);
 842 | 	if (!options.read_stdin) {
 843 | 	  opt_name2_cmp = g_utf8_casefold (opt_name+op1_size+1, -1);
 844 | 	  op2_size = strlen (opt_name2_cmp);
 845 | 	}
 846 |       }
 847 |       gboolean found = FALSE;
 848 |       if (g_str_has_prefix (wname_cmp, search_for)) {
 849 | 	found = TRUE;
 850 | 	priority1 [p1size++] = boxes [i];
 851 |       }
 852 |       if (!found && ((g_strstr_len (wname_cmp, wn_size, search_for) != NULL) ||
 853 | 		     (op1_size && g_str_has_prefix (opt_name1_cmp, search_for)) ||
 854 | 		     (op2_size && g_str_has_prefix (opt_name2_cmp, search_for)))) {
 855 | 	found = TRUE;
 856 | 	priority2 [p2size++] = boxes [i];
 857 |       }
 858 |       if (!found && ((search_by_letters (wname_cmp, wn_size, search_for, s_size)) ||
 859 | 		     (op1_size && g_strstr_len (opt_name1_cmp, op1_size, search_for) != NULL) ||
 860 | 		     (op2_size && g_strstr_len (opt_name2_cmp, op2_size, search_for) != NULL))) {
 861 | 	found = TRUE;
 862 | 	priority3 [p3size++] = boxes [i];
 863 |       }
 864 |       g_free (wname_cmp);
 865 |       g_free (opt_name1_cmp);
 866 |       g_free (opt_name2_cmp);
 867 |       if (found)
 868 | 	filtered_size++;
 869 |     }
 870 | 
 871 |     for (int i = 0; i < p1size; i++)
 872 |       filtered_boxes [i] = priority1 [i];
 873 |     for (int i = 0; i < p2size; i++)
 874 |       filtered_boxes [p1size+i] = priority2 [i];
 875 |     for (int i = 0; i < p3size; i++)
 876 |       filtered_boxes [p1size+p2size+i] = priority3 [i];
 877 | 
 878 |     free (priority1);
 879 |     free (priority2);
 880 |     free (priority3);
 881 | 
 882 |     draw_mosaic (GTK_LAYOUT (layout), filtered_boxes, filtered_size, 0,
 883 | 		 options.box_width, options.box_height);
 884 |   } else {
 885 |     draw_mosaic (GTK_LAYOUT (layout), boxes, wsize, 0,
 886 | 		 options.box_width, options.box_height);
 887 |   }
 888 | 
 889 |   if (gtk_widget_get_visible (search)) {
 890 |     // Stupid thing to show search entry at top level..
 891 |     gtk_widget_hide (search);
 892 |     gtk_widget_show (search);
 893 |   }
 894 | 
 895 |   g_free (search_for);
 896 | }
 897 | 
 898 | static void draw_mask (GdkDrawable *bitmap, guint size)
 899 | {
 900 |   cairo_t *cr;
 901 | 
 902 |   cr = gdk_cairo_create (bitmap);
 903 | 
 904 |   cairo_save (cr);
 905 |   cairo_rectangle (cr, 0, 0, width, height);
 906 |   cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
 907 |   cairo_fill (cr);
 908 |   cairo_restore (cr);
 909 | 
 910 |   cairo_set_source_rgb (cr, 1, 1, 1);
 911 |   // Show each mosaic_window_box.
 912 |   for (int i = 0; i < boxes_drawn; i++) {
 913 |     cairo_rectangle (cr,
 914 | 		     box_rects[i].x, box_rects[i].y,
 915 | 		     box_rects[i].width, box_rects[i].height);
 916 |     cairo_fill (cr);
 917 |   }
 918 | 
 919 |   // show search entry if it is active.
 920 |   if (search) {
 921 |     if (strlen (mosaic_search_box_get_text (MOSAIC_SEARCH_BOX (search))) ||
 922 | 	(options.vim_mode && gtk_widget_get_visible (search))) {
 923 |       GtkAllocation alloc;
 924 |       gtk_widget_get_allocation (search, &alloc);
 925 |       cairo_rectangle (cr,
 926 | 		       alloc.x,
 927 | 		       alloc.y,
 928 | 		       alloc.width,
 929 | 		       alloc.height);
 930 |       cairo_fill (cr);
 931 |     }
 932 |   }
 933 | 
 934 |   cairo_destroy (cr);
 935 | }
 936 | 
 937 | static void read_stdin ()
 938 | {
 939 |   char buffer [BUFSIZ];
 940 |   char *p;
 941 |   int current_size = 1;
 942 |   in_items = calloc (1, sizeof (char *));
 943 |   wsize = 0;
 944 |   while (fgets (buffer, BUFSIZ, stdin)) {
 945 |     if (wsize == current_size) {
 946 |       current_size *= 2;
 947 |       in_items = realloc (in_items, current_size * sizeof (char *));
 948 |     }
 949 |     if ((p = strchr (buffer, '\n')))
 950 |       *p = '\0';
 951 |     in_items [wsize] = g_strdup (buffer);
 952 |     wsize++;
 953 |   }
 954 | }
 955 | 
 956 | static GdkPixbuf* get_screenshot ()
 957 | {
 958 |   GdkWindow *root_window = gdk_get_default_root_window ();
 959 |   gint x, y;
 960 |   gint swidth, sheight;
 961 | 
 962 |   guint m_offset_x = 0, m_offset_y = 0;
 963 |   gint monitors = gdk_screen_get_n_monitors (gdk_screen_get_default ());
 964 |   if (monitors > 1) {
 965 |     gint px = 0, py = 0;
 966 |     gdk_display_get_pointer (gdk_display_get_default (), NULL, &px, &py, NULL);
 967 |     gint current_monitor = gdk_screen_get_monitor_at_point (gdk_screen_get_default (), px, py);
 968 |     for (int i = 0; i < current_monitor; i++) {
 969 |       GdkRectangle mon_rect;
 970 |       gdk_screen_get_monitor_geometry (gdk_screen_get_default (), i, &mon_rect);
 971 |       m_offset_x += mon_rect.width;
 972 |       m_offset_y += mon_rect.height;
 973 |     }
 974 |   }
 975 | 
 976 |   gdk_drawable_get_size (root_window, &swidth, &sheight);
 977 |   gdk_window_get_origin (root_window, &x, &y);
 978 | 
 979 |   if (swidth <= m_offset_x)
 980 |     m_offset_x = 0;
 981 |   if (sheight <= m_offset_y)
 982 |     m_offset_y = 0;
 983 | 
 984 |   return gdk_pixbuf_get_from_drawable (NULL, root_window, NULL,
 985 | 				       x + options.screenshot_offset_x + m_offset_x,
 986 | 				       y + options.screenshot_offset_y + m_offset_y,
 987 | 				       0, 0,
 988 | 				       swidth - options.screenshot_offset_x - m_offset_x,
 989 | 				       sheight - options.screenshot_offset_y - m_offset_y);
 990 | }
 991 | 
 992 | static void read_config ()
 993 | {
 994 |   // Set default options.
 995 |   options.vim_mode = FALSE;
 996 |   options.box_width = 200;
 997 |   options.box_height = 40;
 998 |   options.colorize = TRUE;
 999 |   options.color_offset = 0;
1000 |   options.show_icons = TRUE;
1001 |   options.show_desktop = TRUE;
1002 |   options.show_titles = TRUE;
1003 |   options.icon_size = 16;
1004 |   options.font = g_strdup ("Sans 10");
1005 |   options.read_stdin = FALSE;
1006 |   options.screenshot = FALSE;
1007 |   options.screenshot_offset_x = 0;
1008 |   options.screenshot_offset_y = 0;
1009 | 
1010 |   gchar *filename = g_strjoin ("/", g_get_user_config_dir (), "xwinmosaic/config", NULL);
1011 | 
1012 |   GError *error = NULL;
1013 |   GKeyFile *config = g_key_file_new ();
1014 | 
1015 |   if (!g_key_file_load_from_file (config, filename, 0, &error)) {
1016 |     write_default_config ();
1017 |     return;
1018 |   }
1019 | 
1020 |   const gchar *group = "default";
1021 |   if (g_key_file_has_group (config, group)) {
1022 |     if (g_key_file_has_key (config, group, "vim_mode", &error))
1023 |       options.vim_mode = g_key_file_get_boolean (config, group, "vim_mode", &error);
1024 |     if (g_key_file_has_key (config, group, "box_width", &error))
1025 |       options.box_width = g_key_file_get_integer (config, group, "box_width", &error);
1026 |     if (g_key_file_has_key (config, group, "box_height", &error))
1027 |       options.box_height = g_key_file_get_integer (config, group, "box_height", &error);
1028 |     if (g_key_file_has_key (config, group, "colorize", &error))
1029 |       options.colorize = g_key_file_get_boolean (config, group, "colorize", &error);
1030 |     if (g_key_file_has_key (config, group, "color_offset", &error))
1031 |       options.color_offset = g_key_file_get_integer (config, group, "color_offset", &error);
1032 |     if (g_key_file_has_key (config, group, "show_icons", &error))
1033 |       options.show_icons = g_key_file_get_boolean (config, group, "show_icons", &error);
1034 |     if (g_key_file_has_key (config, group, "show_desktop", &error))
1035 |       options.show_desktop = g_key_file_get_boolean (config, group, "show_desktop", &error);
1036 |     if (g_key_file_has_key (config, group, "show_titles", &error))
1037 |       options.show_titles = g_key_file_get_boolean (config, group, "show_titles", &error);
1038 |     if (g_key_file_has_key (config, group, "icon_size", &error))
1039 |       options.icon_size = g_key_file_get_integer (config, group, "icon_size", &error);
1040 |     if (g_key_file_has_key (config, group, "font", &error))
1041 |       options.font = g_key_file_get_string (config, group, "font", &error);
1042 |     if (g_key_file_has_key (config, group, "screenshot", &error))
1043 |       options.screenshot = g_key_file_get_boolean (config, group, "screenshot", &error);
1044 |     if (g_key_file_has_key (config, group, "screenshot_offset_x", &error))
1045 |       options.screenshot_offset_x = g_key_file_get_integer (config, group, "screenshot_offset_x", &error);
1046 |     if (g_key_file_has_key (config, group, "screenshot_offset_y", &error))
1047 |       options.screenshot_offset_y = g_key_file_get_integer (config, group, "screenshot_offset_y", &error);
1048 |     if (g_key_file_has_key (config, group, "at_pointer", &error))
1049 |       options.at_pointer = g_key_file_get_boolean (config, group, "at_pointer", &error);
1050 |     if (g_key_file_has_key (config, group, "color_file", &error))
1051 |       options.color_file = g_key_file_get_string (config, group, "color_file", &error);
1052 |   }
1053 | 
1054 |   g_key_file_free (config);
1055 | }
1056 | 
1057 | static void write_default_config ()
1058 | {
1059 |   gchar *confdir = g_strjoin ("/", g_get_user_config_dir (), "xwinmosaic", NULL);
1060 |   gchar *filename = g_strjoin ("/", g_get_user_config_dir (), "xwinmosaic/config", NULL);
1061 | 
1062 |   if (g_mkdir_with_parents (confdir, 0755) != -1) {
1063 |     FILE *config;
1064 |     if ((config = fopen (filename, "w")) != NULL) {
1065 |       fprintf (config, "[default]\n");
1066 |       fprintf (config, "vim_mode = %s\n", (options.vim_mode) ? "true" : "false");
1067 |       fprintf (config, "box_width = %d\n", options.box_width);
1068 |       fprintf (config, "box_height = %d\n", options.box_height);
1069 |       fprintf (config, "colorize = %s\n", (options.colorize) ? "true" : "false");
1070 |       fprintf (config, "color_offset = %d\n", options.color_offset);
1071 |       fprintf (config, "show_icons = %s\n", (options.show_icons) ? "true" : "false");
1072 |       fprintf (config, "show_desktop = %s\n", (options.show_desktop) ? "true" : "false");
1073 |       fprintf (config, "show_titles = %s\n", (options.show_titles) ? "true" : "false");
1074 |       fprintf (config, "icon_size = %d\n", options.icon_size);
1075 |       fprintf (config, "font = %s\n", options.font);
1076 |       fprintf (config, "screenshot = %s\n", (options.screenshot) ? "true" : "false");
1077 |       fprintf (config, "screenshot_offset_x = %d\n", options.screenshot_offset_x);
1078 |       fprintf (config, "screenshot_offset_y = %d\n", options.screenshot_offset_y);
1079 |       fprintf (config, "at_pointer = %s\n", (options.at_pointer) ? "true" : "false");
1080 |       fprintf (config, "# color_file = /path/to/file\n");
1081 |       fclose (config);
1082 |       }
1083 |   }
1084 | 
1085 |   g_printerr ("created new config in %s\n", confdir);
1086 | }
1087 | 
1088 | static void on_focus_change (GtkWidget *widget, GdkEventFocus *event, gpointer data)
1089 | {
1090 |   if (event->in == FALSE) { /* focus out */
1091 |     /* workaround for awesome wm and its unexpected focus changes */
1092 |     if (options.screenshot && !key_pressed)
1093 |       return;
1094 |     if (options.persistent)
1095 |       gtk_widget_hide (window);
1096 |     else
1097 |       gtk_main_quit ();
1098 |   }
1099 | }
1100 | 
1101 | static void read_colors ()
1102 | {
1103 | 
1104 |   GError *error = NULL;
1105 |   color_config = g_key_file_new ();
1106 | 
1107 |   if (!g_key_file_load_from_file (color_config, options.color_file, 0, &error)) {
1108 |     g_printerr ("%s\n", error->message);
1109 |     return;
1110 |   }
1111 | 
1112 |   fallback_size = 0;
1113 | 
1114 |   const gchar *group = "colors";
1115 |   if (g_key_file_has_group (color_config, group)) {
1116 |     if (g_key_file_has_key (color_config, group, "fallback", &error))
1117 |       fallback_colors = g_key_file_get_string_list (color_config, group, "fallback", &fallback_size, &error);
1118 |   }
1119 | }
1120 | static gboolean parse_format (Entry* entry, char *data)
1121 | {
1122 |   gchar **opts = g_strsplit(data, ",", 5);
1123 |   if(!opts[1] + !opts[2] + !opts[3] + !opts[4]) { //What did i just write?
1124 |     g_printerr("Format error\n");
1125 |     return FALSE;
1126 |   }
1127 |   g_strchug(opts[0]);
1128 |   if(g_ascii_isdigit(opts[0][0])) {
1129 |     if(sscanf(opts[0], "%d", &(entry->desktop))==EOF) return FALSE;
1130 |   } else
1131 |       entry->desktop = -1;
1132 |   entry->color = opts[1];
1133 |   entry->iconpath = opts[2];
1134 |   entry->label = opts[3];
1135 |   entry->opt_name = opts[4];
1136 |   //g_strfreev(opts);
1137 |   g_strchug(entry->color);
1138 |   g_strchug(entry->iconpath);
1139 |   g_strchug(entry->label);
1140 |   g_strchug(entry->opt_name);
1141 |   return TRUE;
1142 | }
1143 | 
1144 | void tab_event (gboolean shift) //FIXME: put prototype for this function
1145 |                                 //in some header file
1146 | {
1147 |   gboolean is_visible = FALSE;
1148 |   g_object_get (window, "visible", &is_visible, NULL);
1149 |   if(is_visible) {
1150 |     GtkWidget **bs;
1151 |     guint bsize = 0;
1152 |     if(gtk_widget_get_visible (search)) {
1153 |       bs = filtered_boxes;
1154 |       bsize = filtered_size;
1155 |     } else {
1156 |       bs = boxes;
1157 |       bsize = wsize;
1158 |     }
1159 |     if (bsize == 0) return; // nothing to switch between
1160 |     // Calculate current box by straightforward pointer comparison
1161 |     guint current_box = 0;
1162 |     MosaicWindowBox* box = MOSAIC_WINDOW_BOX (gtk_window_get_focus (GTK_WINDOW (window)));
1163 |     for (guint i = 0; i < bsize; i++)
1164 |       if (MOSAIC_WINDOW_BOX(box) == MOSAIC_WINDOW_BOX(bs[i])) {
1165 | 	current_box = i;
1166 | 	break;
1167 |       }
1168 |     if(!shift) {
1169 | 	current_box < bsize-1 ? current_box++ : (current_box = 0);
1170 |     } else {
1171 | 	current_box > 0 ? current_box-- : (current_box = bsize-1);
1172 |     }
1173 |     gtk_widget_grab_focus (bs[current_box]);
1174 |   } else {
1175 |     update_box_list();
1176 |     draw_mosaic (GTK_LAYOUT (layout), boxes, wsize, 0,
1177 |                  options.box_width, options.box_height);
1178 |     gtk_window_present (GTK_WINDOW (window));
1179 |   }
1180 | }
1181 | 


--------------------------------------------------------------------------------
/src/mosaic_box.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (c) 2012, Anton S. Lobashev
  2 |  * mosaic_box.c - common stuff for window_box and search_box.
  3 |  */
  4 | 
  5 | #include "mosaic_box.h"
  6 | 
  7 | #define BOX_DEFAULT_WIDTH 200
  8 | #define BOX_DEFAULT_HEIGHT 40
  9 | 
 10 | enum {
 11 |   CLICKED,
 12 |   LAST_SIGNAL
 13 | };
 14 | 
 15 | static GObject *mosaic_box_constructor (GType gtype,
 16 | 					guint n_properties,
 17 | 					GObjectConstructParam *properties);
 18 | static void mosaic_box_dispose (GObject *gobject);
 19 | static void mosaic_box_realize (GtkWidget *widget);
 20 | static void mosaic_box_size_request (GtkWidget *widget, GtkRequisition *requisition);
 21 | static void mosaic_box_size_allocate (GtkWidget *widget,GtkAllocation *allocation);
 22 | 
 23 | static gboolean mosaic_box_button_press (GtkWidget *widget, GdkEventButton *event);
 24 | static gboolean mosaic_box_button_release (GtkWidget *widget, GdkEventButton *event);
 25 | static gboolean mosaic_box_key_press (GtkWidget *widget, GdkEventKey *event);
 26 | static gboolean mosaic_box_key_release (GtkWidget *widget, GdkEventKey *event);
 27 | static gboolean mosaic_box_enter_notify (GtkWidget *widget, GdkEventCrossing *event);
 28 | static gboolean mosaic_box_leave_notify (GtkWidget *widget, GdkEventCrossing *event);
 29 | 
 30 | static void mosaic_box_clicked (MosaicBox *box);
 31 | 
 32 | static guint box_signals[LAST_SIGNAL] = { 0 };
 33 | 
 34 | G_DEFINE_TYPE (MosaicBox, mosaic_box, GTK_TYPE_DRAWING_AREA);
 35 | 
 36 | static void
 37 | mosaic_box_class_init (MosaicBoxClass *klass)
 38 | {
 39 |   GObjectClass *gobject_class;
 40 |   GtkWidgetClass *widget_class;
 41 | 
 42 |   gobject_class = G_OBJECT_CLASS (klass);
 43 |   widget_class = GTK_WIDGET_CLASS (klass);
 44 | 
 45 |   gobject_class->constructor = mosaic_box_constructor;
 46 |   gobject_class->dispose = mosaic_box_dispose;
 47 | 
 48 |   widget_class->realize = mosaic_box_realize;
 49 |   widget_class->size_request = mosaic_box_size_request;
 50 |   widget_class->size_allocate = mosaic_box_size_allocate;
 51 |   widget_class->button_press_event = mosaic_box_button_press;
 52 |   widget_class->button_release_event = mosaic_box_button_release;
 53 |   widget_class->key_press_event = mosaic_box_key_press;
 54 |   widget_class->key_release_event = mosaic_box_key_release;
 55 |   widget_class->enter_notify_event = mosaic_box_enter_notify;
 56 |   widget_class->leave_notify_event = mosaic_box_leave_notify;
 57 | 
 58 |   klass->clicked = NULL;
 59 | 
 60 |   box_signals [CLICKED] =
 61 |     g_signal_new ("clicked",
 62 | 		  G_TYPE_FROM_CLASS (gobject_class),
 63 | 		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 64 | 		  G_STRUCT_OFFSET (MosaicBoxClass, clicked),
 65 | 		  NULL, NULL,
 66 | 		  g_cclosure_marshal_VOID__VOID,
 67 | 		  G_TYPE_NONE, 0);
 68 | }
 69 | 
 70 | static void
 71 | mosaic_box_init (MosaicBox *box)
 72 | {
 73 |   gtk_widget_set_can_focus (GTK_WIDGET (box), TRUE);
 74 |   gtk_widget_set_receives_default (GTK_WIDGET (box), TRUE);
 75 | 
 76 |   box->name = NULL;
 77 | }
 78 | 
 79 | static GObject*	mosaic_box_constructor (GType gtype,
 80 | 					guint n_properties,
 81 | 					GObjectConstructParam *properties)
 82 | {
 83 |   GObject *obj;
 84 |   MosaicBox *box;
 85 | 
 86 |   obj = G_OBJECT_CLASS (mosaic_box_parent_class)->constructor (gtype, n_properties, properties);
 87 | 
 88 |   box = MOSAIC_BOX (obj);
 89 | 
 90 |   box->font = g_strdup ("Sans 10");
 91 |   box->on_box = FALSE;
 92 |   box->box_down = FALSE;
 93 | 
 94 |   return obj;
 95 | }
 96 | 
 97 | GtkWidget* mosaic_box_new (void)
 98 | {
 99 |   return g_object_new (MOSAIC_TYPE_BOX, NULL);
100 | }
101 | 
102 | GtkWidget* mosaic_box_new_with_name (gchar *name)
103 | {
104 |   return g_object_new (MOSAIC_TYPE_BOX, "name", name, NULL);
105 | }
106 | 
107 | static void
108 | mosaic_box_dispose (GObject *gobject)
109 | {
110 |   MosaicBox *box = MOSAIC_BOX (gobject);
111 |   if (box->name)
112 |     g_free (box->name);
113 |   box->name = NULL;
114 | 
115 |   if (box->font)
116 |     g_free (box->font);
117 |   box->font = NULL;
118 | 
119 |   G_OBJECT_CLASS (mosaic_box_parent_class)->dispose (gobject);
120 | }
121 | 
122 | static void mosaic_box_realize (GtkWidget *widget)
123 | {
124 |   GdkWindowAttr attributes;
125 |   gint attributes_mask;
126 | 
127 |   g_return_if_fail (MOSAIC_IS_BOX (widget));
128 | 
129 |   gtk_widget_set_realized (widget, TRUE);
130 | 
131 |   attributes.window_type = GDK_WINDOW_CHILD;
132 |   attributes.x = widget->allocation.x;
133 |   attributes.y = widget->allocation.y;
134 |   attributes.width = widget->allocation.width;
135 |   attributes.height = widget->allocation.height;
136 |   attributes.wclass = GDK_INPUT_OUTPUT;
137 |   attributes.event_mask = gtk_widget_get_events (widget);
138 |   attributes.event_mask |= (GDK_EXPOSURE_MASK |
139 | 			    GDK_BUTTON_PRESS_MASK |
140 | 			    GDK_BUTTON_RELEASE_MASK |
141 | 			    GDK_ENTER_NOTIFY_MASK |
142 | 			    GDK_LEAVE_NOTIFY_MASK);
143 | 
144 |   attributes.visual = gtk_widget_get_visual (widget);
145 |   attributes.colormap = gtk_widget_get_colormap (widget);
146 | 
147 |   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
148 | 
149 |   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
150 | 				   &attributes, attributes_mask);
151 | 
152 |   gdk_window_set_user_data (widget->window, widget);
153 | 
154 |   widget->style = gtk_style_attach (widget->style, widget->window);
155 | }
156 | 
157 | static void mosaic_box_size_request (GtkWidget *widget, GtkRequisition *requisition)
158 | {
159 |   requisition->width = BOX_DEFAULT_WIDTH;
160 |   requisition->height = BOX_DEFAULT_HEIGHT;
161 | }
162 | 
163 | static void mosaic_box_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
164 | {
165 |   g_return_if_fail (MOSAIC_IS_BOX (widget));
166 |   g_return_if_fail (allocation != NULL);
167 | 
168 |   GTK_WIDGET_CLASS (mosaic_box_parent_class)->size_allocate (widget, allocation);
169 | 
170 |   widget->allocation = *allocation;
171 |   if (gtk_widget_get_realized (widget)) {
172 |     gdk_window_move_resize (widget->window,
173 | 			    allocation->x, allocation->y,
174 | 			    allocation->width, allocation->height);
175 |   }
176 | }
177 | 
178 | static gboolean mosaic_box_button_press (GtkWidget *widget, GdkEventButton *event)
179 | {
180 |   MosaicBox *box;
181 | 
182 |   if (event->type == GDK_BUTTON_PRESS && gtk_widget_get_can_focus (widget))
183 |   {
184 |     box = MOSAIC_BOX (widget);
185 |     if (event->button == 1) {
186 |       box->box_down = TRUE;
187 |       gtk_widget_grab_focus (widget);
188 |     }
189 |   }
190 | 
191 |   return TRUE;
192 | }
193 | 
194 | static gboolean mosaic_box_button_release (GtkWidget *widget, GdkEventButton *event)
195 | {
196 |   MosaicBox *box;
197 | 
198 |   if (event->type == GDK_BUTTON_RELEASE && gtk_widget_get_can_focus (widget))
199 |   {
200 |     box = MOSAIC_BOX (widget);
201 |     if (event->button == 1 && box->on_box && box->box_down)
202 |       mosaic_box_clicked (MOSAIC_BOX (widget));
203 |     box->box_down = FALSE;
204 |   }
205 | 
206 |   return TRUE;
207 | }
208 | static gboolean mosaic_box_key_press (GtkWidget *widget, GdkEventKey *event)
209 | {
210 |   MosaicBox *box = MOSAIC_BOX (widget);
211 |   if ((event->keyval == GDK_Return ||
212 |       event->keyval == GDK_KP_Enter ||
213 |       event->keyval == GDK_ISO_Enter) &&
214 |       gtk_widget_get_can_focus (widget))
215 |   {
216 |     box->box_down = TRUE;
217 |   }
218 |   return FALSE;
219 | }
220 | 
221 | static gboolean mosaic_box_key_release (GtkWidget *widget, GdkEventKey *event)
222 | {
223 |   MosaicBox *box = MOSAIC_BOX (widget);
224 |   if ((event->keyval == GDK_Return ||
225 |        event->keyval == GDK_KP_Enter ||
226 |        event->keyval == GDK_ISO_Enter) &&
227 |       box->box_down &&
228 |       gtk_widget_get_can_focus (widget))
229 |   {
230 |     mosaic_box_clicked (box);
231 |     box->box_down = FALSE;
232 |   }
233 |   return FALSE;
234 | }
235 | 
236 | static gboolean mosaic_box_enter_notify (GtkWidget * widget, GdkEventCrossing * event)
237 | {
238 |   MosaicBox *box;
239 |   GtkWidget *event_widget;
240 | 
241 |   box = MOSAIC_BOX (widget);
242 |   event_widget = gtk_get_event_widget ((GdkEvent *) event);
243 | 
244 |   if ((event_widget == widget) && (event->detail != GDK_NOTIFY_INFERIOR)) {
245 |     box->on_box = TRUE;
246 |     gtk_widget_queue_draw (widget);
247 |   }
248 | 
249 |   return FALSE;
250 | }
251 | 
252 | static gboolean mosaic_box_leave_notify (GtkWidget * widget, GdkEventCrossing * event)
253 | {
254 |   MosaicBox *box;
255 |   GtkWidget *event_widget;
256 | 
257 |   box = MOSAIC_BOX (widget);
258 |   event_widget = gtk_get_event_widget ((GdkEvent *) event);
259 | 
260 |   if ((event_widget == widget) && (event->detail != GDK_NOTIFY_INFERIOR)) {
261 |     box->on_box = FALSE;
262 |     gtk_widget_queue_draw (widget);
263 |   }
264 | 
265 |   return FALSE;
266 | }
267 | 
268 | void mosaic_box_clicked (MosaicBox *box)
269 | {
270 |   g_signal_emit (box, box_signals [CLICKED], 0);
271 | }
272 | 
273 | void
274 | mosaic_box_set_name (MosaicBox *box, const gchar *name)
275 | {
276 |   gchar *new_name;
277 |   g_return_if_fail (MOSAIC_IS_BOX (box));
278 | 
279 |   new_name = g_strdup (name);
280 |   g_free (box->name);
281 |   box->name = new_name;
282 | 
283 |   gtk_widget_queue_draw (GTK_WIDGET (box));
284 | }
285 | 
286 | const gchar *
287 | mosaic_box_get_name (MosaicBox *box)
288 | {
289 |   g_return_val_if_fail (MOSAIC_IS_BOX (box), NULL);
290 | 
291 |   return box->name;
292 | }
293 | 
294 | void mosaic_box_paint (MosaicBox *box, cairo_t *cr, gint width, gint height)
295 | {
296 |   gboolean has_focus = gtk_widget_has_focus (GTK_WIDGET (box));
297 | 
298 |   // Draw border
299 |   cairo_rectangle (cr, 0, 0, width, height);
300 |   if (has_focus) {
301 |     cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
302 |     cairo_set_line_width (cr, 4);
303 |     cairo_stroke_preserve (cr);
304 |   }
305 |   cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
306 |   cairo_set_line_width (cr, 1);
307 |   cairo_stroke (cr);
308 | }
309 | 
310 | void mosaic_box_set_font (MosaicBox *box, const gchar *font)
311 | {
312 |   g_return_if_fail (MOSAIC_IS_BOX (box));
313 | 
314 |   if (box->font)
315 |     g_free (box->font);
316 | 
317 |   box->font = g_strdup (font);
318 | }
319 | 


--------------------------------------------------------------------------------
/src/mosaic_box.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (c) 2012, Anton S. Lobashev
 2 |  * mosaic_box.h - headers for mosaic_box class.
 3 |  */
 4 | 
 5 | #ifndef MOSAIC_BOX_H
 6 | #define MOSAIC_BOX_H
 7 | 
 8 | #include <gtk/gtk.h>
 9 | #include <cairo.h>
10 | #include <gdk/gdkkeysyms.h>
11 | #include <string.h>
12 | 
13 | G_BEGIN_DECLS
14 | 
15 | #define MOSAIC_TYPE_BOX            (mosaic_box_get_type ())
16 | #define MOSAIC_BOX(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MOSAIC_TYPE_BOX, MosaicBox))
17 | #define MOSAIC_BOX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MOSAIC_TYPE_BOX, MosaicBoxClass))
18 | #define MOSAIC_IS_BOX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MOSAIC_TYPE_BOX))
19 | #define MOSAIC_IS_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOSAIC_TYPE_BOX))
20 | #define MOSAIC_BOX_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MOSAIC_TYPE_BOX, MosaicBoxClass))
21 | 
22 | typedef struct _MosaicBox      MosaicBox;
23 | typedef struct _MosaicBoxClass MosaicBoxClass;
24 | 
25 | struct _MosaicBox
26 | {
27 |   GtkDrawingArea parent;
28 | 
29 |   /*< private >*/
30 |   gchar *name;
31 | 
32 |   gboolean on_box;
33 |   gboolean box_down;
34 | 
35 |   gchar *font;
36 | };
37 | 
38 | struct _MosaicBoxClass
39 | {
40 |   GtkDrawingAreaClass parent_class;
41 | 
42 |   void (* clicked)  (MosaicBox *box);
43 | };
44 | 
45 | GType mosaic_box_get_type (void);
46 | GtkWidget* mosaic_box_new (void);
47 | void mosaic_box_set_name (MosaicBox *box, const gchar *name);
48 | const gchar *mosaic_box_get_name (MosaicBox *box);
49 | 
50 | void mosaic_box_paint (MosaicBox *box, cairo_t *cr, gint width, gint height);
51 | void mosaic_box_set_font (MosaicBox *box, const gchar *font);
52 | 
53 | G_END_DECLS
54 | 
55 | #endif /* MOSAIC_BOX_H */
56 | 


--------------------------------------------------------------------------------
/src/mosaic_search_box.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (c) 2012, Anton S. Lobashev
  2 |  * mosaic_seach_box.c - search box widget.
  3 |  */
  4 | 
  5 | #include "mosaic_search_box.h"
  6 | 
  7 | #define BOX_DEFAULT_WIDTH 200
  8 | 
  9 | enum {
 10 |   CHANGED,
 11 |   LAST_SIGNAL
 12 | };
 13 | 
 14 | enum {
 15 |   PROP_0,
 16 |   PROP_TEXT,
 17 |   N_PROPERTIES
 18 | };
 19 | 
 20 | static GObject*	mosaic_search_box_constructor (GType gtype,
 21 | 					       guint n_properties,
 22 | 					       GObjectConstructParam *properties);
 23 | static void mosaic_search_box_dispose (GObject *gobject);
 24 | 
 25 | static void mosaic_search_box_set_property (GObject *gobject,
 26 | 					    guint prop_id,
 27 | 					    const GValue *value,
 28 | 					    GParamSpec *pspec);
 29 | static void mosaic_search_box_get_property (GObject *gobject,
 30 | 					    guint prop_id,
 31 | 					    GValue *value,
 32 | 					    GParamSpec *pspec);
 33 | 
 34 | static gboolean mosaic_search_box_expose_event (GtkWidget *widget, GdkEventExpose *event);
 35 | static void mosaic_search_box_paint (MosaicSearchBox *box, cairo_t *cr, gint width, gint height);
 36 | static void mosaic_search_box_size_request (GtkWidget *widget, GtkRequisition *requisition);
 37 | 
 38 | static guint search_box_signals[LAST_SIGNAL] = { 0 };
 39 | static GParamSpec *obj_properties[N_PROPERTIES] = { NULL };
 40 | 
 41 | G_DEFINE_TYPE (MosaicSearchBox, mosaic_search_box, MOSAIC_TYPE_BOX);
 42 | 
 43 | static void
 44 | mosaic_search_box_class_init (MosaicSearchBoxClass *klass)
 45 | {
 46 |   GObjectClass *gobject_class;
 47 |   GtkWidgetClass *widget_class;
 48 | 
 49 |   gobject_class = G_OBJECT_CLASS (klass);
 50 |   widget_class = GTK_WIDGET_CLASS (klass);
 51 | 
 52 |   gobject_class->constructor = mosaic_search_box_constructor;
 53 |   gobject_class->dispose = mosaic_search_box_dispose;
 54 |   gobject_class->set_property = mosaic_search_box_set_property;
 55 |   gobject_class->get_property = mosaic_search_box_get_property;
 56 | 
 57 |   widget_class->expose_event = mosaic_search_box_expose_event;
 58 |   widget_class->size_request = mosaic_search_box_size_request;
 59 | 
 60 |   obj_properties[PROP_TEXT] =
 61 |     g_param_spec_string ("text",
 62 | 			 "Text in the search entry",
 63 | 			 "Text, displayed in search entry",
 64 | 			 NULL,
 65 | 			 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
 66 | 
 67 |   g_object_class_install_property (gobject_class, PROP_TEXT, obj_properties [PROP_TEXT]);
 68 | 
 69 |   search_box_signals [CHANGED] =
 70 |     g_signal_new ("changed",
 71 | 		  G_TYPE_FROM_CLASS (gobject_class),
 72 | 		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 73 | 		  G_STRUCT_OFFSET (MosaicSearchBoxClass, changed),
 74 | 		  NULL, NULL,
 75 | 		  g_cclosure_marshal_VOID__VOID,
 76 | 		  G_TYPE_NONE, 0);
 77 | 
 78 | }
 79 | 
 80 | static void
 81 | mosaic_search_box_init (MosaicSearchBox *box)
 82 | {
 83 |   gtk_widget_set_can_focus (GTK_WIDGET (box), FALSE);
 84 |   gtk_widget_set_receives_default (GTK_WIDGET (box), FALSE);
 85 | }
 86 | 
 87 | static GObject*	mosaic_search_box_constructor (GType gtype,
 88 | 					guint n_properties,
 89 | 					GObjectConstructParam *properties)
 90 | {
 91 |   GObject *obj;
 92 |   MosaicSearchBox *box;
 93 | 
 94 |   obj = G_OBJECT_CLASS (mosaic_search_box_parent_class)->constructor (gtype, n_properties, properties);
 95 | 
 96 |   box = MOSAIC_SEARCH_BOX (obj);
 97 | 
 98 |   MOSAIC_BOX (box)->name = g_strdup("\0");
 99 |   box->cursor = g_strdup ("|");
100 | 
101 |   return obj;
102 | }
103 | 
104 | GtkWidget* mosaic_search_box_new (void)
105 | {
106 |   return g_object_new (MOSAIC_TYPE_SEARCH_BOX, NULL);
107 | }
108 | 
109 | static void
110 | mosaic_search_box_dispose (GObject *gobject)
111 | {
112 |   MosaicSearchBox *box = MOSAIC_SEARCH_BOX (gobject);
113 | 
114 |   if (box->cursor)
115 |     g_free (box->cursor);
116 |   box->cursor = NULL;
117 | 
118 |   G_OBJECT_CLASS (mosaic_search_box_parent_class)->dispose (gobject);
119 | }
120 | 
121 | static void mosaic_search_box_set_property (GObject *gobject,
122 | 					    guint prop_id,
123 | 					    const GValue *value,
124 | 					    GParamSpec *pspec)
125 | {
126 |   MosaicSearchBox *box = MOSAIC_SEARCH_BOX (gobject);
127 | 
128 |   switch (prop_id) {
129 |   case PROP_TEXT:
130 |     mosaic_search_box_set_text (box, g_value_get_string (value));
131 |     break;
132 |   default:
133 |     G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
134 |     break;
135 |   }
136 | }
137 | 
138 | static void mosaic_search_box_get_property (GObject *gobject,
139 | 					    guint prop_id,
140 | 					    GValue *value,
141 | 					    GParamSpec *pspec)
142 | {
143 |   MosaicSearchBox *box = MOSAIC_SEARCH_BOX (gobject);
144 | 
145 |   switch (prop_id) {
146 |   case PROP_TEXT:
147 |     g_value_set_string (value, MOSAIC_BOX(box)->name);
148 |     break;
149 |   default:
150 |     G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
151 |     break;
152 |   }
153 | }
154 | 
155 | static gboolean
156 | mosaic_search_box_expose_event (GtkWidget *widget, GdkEventExpose *event)
157 | {
158 |   g_return_val_if_fail (MOSAIC_IS_SEARCH_BOX (widget), FALSE);
159 | 
160 |   cairo_t *cr;
161 |   cr = gdk_cairo_create (widget->window);
162 |   cairo_rectangle (cr,
163 | 		   event->area.x, event->area.y,
164 | 		   event->area.width, event->area.height);
165 |   cairo_clip (cr);
166 |   mosaic_search_box_paint (MOSAIC_SEARCH_BOX (widget), cr, widget->allocation.width, widget->allocation.height);
167 |   cairo_destroy (cr);
168 |   return TRUE;
169 | }
170 | 
171 | static void
172 | mosaic_search_box_paint (MosaicSearchBox *box, cairo_t *cr, gint width, gint height)
173 | {
174 |   cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
175 |   cairo_rectangle (cr, 0, 0, width, height);
176 |   cairo_fill (cr);
177 | 
178 |   PangoLayout *pl;
179 |   PangoFontDescription *pfd;
180 |   pl = pango_cairo_create_layout (cr);
181 |   pango_layout_set_text (pl, MOSAIC_BOX (box)->name, -1);
182 |   pfd = pango_font_description_from_string (MOSAIC_BOX (box)->font);
183 |   pango_layout_set_font_description (pl, pfd);
184 |   pango_font_description_free (pfd);
185 | 
186 |   int pwidth, pheight;
187 |   pango_layout_get_pixel_size (pl, &pwidth, &pheight);
188 | 
189 |   cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0);
190 | 
191 |   if ((width-pwidth) < 10)
192 |     cairo_move_to (cr, width-pwidth-5, (height-pheight)/2);
193 |   else
194 |     cairo_move_to (cr, 5, (height-pheight)/2);
195 | 
196 |   pango_cairo_show_layout (cr, pl);
197 |   g_object_unref (pl);
198 | 
199 |   if ((width-pwidth) < 10)
200 |     cairo_rectangle (cr, width-4, 5, 2, height-10);
201 |   else
202 |     cairo_rectangle (cr, pwidth+6, 5, 2, height-10);
203 |   cairo_fill (cr);
204 | 
205 |   mosaic_box_paint (MOSAIC_BOX (box), cr, width, height);
206 | }
207 | 
208 | static void mosaic_search_box_size_request (GtkWidget *widget, GtkRequisition *requisition)
209 | {
210 |   PangoLayout *pl = gtk_widget_create_pango_layout (widget, "|");
211 |   PangoFontDescription *pfd = pango_font_description_from_string (MOSAIC_BOX (widget)->font);
212 |   pango_layout_set_font_description (pl, pfd);
213 |   pango_font_description_free (pfd);
214 | 
215 |   int pwidth, pheight;
216 |   pango_layout_get_pixel_size (pl, &pwidth, &pheight);
217 | 
218 |   requisition->width = BOX_DEFAULT_WIDTH;
219 |   requisition->height = pheight + 10;
220 |   g_object_unref (pl);
221 | }
222 | 
223 | void
224 | mosaic_search_box_set_text (MosaicSearchBox *box, const gchar *text)
225 | {
226 |   mosaic_box_set_name (MOSAIC_BOX (box), text);
227 |   g_signal_emit (box, search_box_signals [CHANGED], 0);
228 | }
229 | 
230 | const gchar *
231 | mosaic_search_box_get_text (MosaicSearchBox *box)
232 | {
233 |   g_return_val_if_fail (MOSAIC_IS_SEARCH_BOX (box), NULL);
234 | 
235 |   return MOSAIC_BOX (box)->name;
236 | }
237 | 
238 | void mosaic_search_box_append_text (MosaicSearchBox *box, const gchar *text)
239 | {
240 |   gchar *new_text = g_strjoin (NULL, mosaic_search_box_get_text (box), text, NULL);
241 |   mosaic_search_box_set_text (box, new_text);
242 |   g_free (new_text);
243 | }
244 | 
245 | void mosaic_search_box_remove_symbols (MosaicSearchBox *box, guint size)
246 | {
247 |   gchar *text = g_strdup (mosaic_search_box_get_text (box));
248 |   if (strlen (text)) {
249 |     gchar *p = text + strlen (text);
250 |     for (int i = 0; i < size; i++) {
251 |       p = g_utf8_find_prev_char (text, p);
252 |       *p = '\0';
253 |     }
254 |     mosaic_search_box_set_text (box, text);
255 |   }
256 |   g_free (text);
257 | }
258 | 
259 | void mosaic_search_box_kill_word (MosaicSearchBox *box)
260 | {
261 |   const gchar *text = mosaic_search_box_get_text (box);
262 |   gint size = strlen (text);
263 |   if (size) {
264 |     const gchar *p = text + size;
265 |     int len = 0;
266 |     while (p > text) {
267 |       p = g_utf8_find_prev_char (text, p);
268 |       gunichar c = g_utf8_get_char (p);
269 |       if (g_unichar_isspace (c) && len > 0)
270 | 	break;
271 | 
272 |       len++;
273 |     }
274 |     mosaic_search_box_remove_symbols (box, len);
275 |   }
276 | }
277 | 


--------------------------------------------------------------------------------
/src/mosaic_search_box.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (c) 2012, Anton S. Lobashev
 2 |  * mosaic_seach_box.h - headers for search box widget.
 3 |  */
 4 | 
 5 | #ifndef MOSAIC_SEARCH_BOX_H
 6 | #define MOSAIC_SEARCH_BOX_H
 7 | 
 8 | #include <glib.h>
 9 | #include <string.h>
10 | #include "mosaic_box.h"
11 | 
12 | G_BEGIN_DECLS
13 | 
14 | #define MOSAIC_TYPE_SEARCH_BOX            (mosaic_search_box_get_type ())
15 | #define MOSAIC_SEARCH_BOX(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MOSAIC_TYPE_SEARCH_BOX, MosaicSearchBox))
16 | #define MOSAIC_SEARCH_BOX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MOSAIC_TYPE_SEARCH_BOX, MosaicSearchBoxClass))
17 | #define MOSAIC_IS_SEARCH_BOX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MOSAIC_TYPE_SEARCH_BOX))
18 | #define MOSAIC_IS_SEARCH_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOSAIC_TYPE_SEARCH_BOX))
19 | #define MOSAIC_SEARCH_BOX_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MOSAIC_TYPE_SEARCH_BOX, MosaicSearchBoxClass))
20 | 
21 | typedef struct _MosaicSearchBox      MosaicSearchBox;
22 | typedef struct _MosaicSearchBoxClass MosaicSearchBoxClass;
23 | 
24 | struct _MosaicSearchBox
25 | {
26 |   MosaicBox parent;
27 | 
28 |   /*< private >*/
29 |   gchar *cursor;
30 | };
31 | 
32 | struct _MosaicSearchBoxClass
33 | {
34 |   MosaicBoxClass parent_class;
35 | 
36 |   void (* changed) (MosaicSearchBox *box);
37 | };
38 | 
39 | GType mosaic_search_box_get_type (void);
40 | GtkWidget *mosaic_search_box_new (void);
41 | void mosaic_search_box_set_text (MosaicSearchBox *box, const gchar *text);
42 | const gchar *mosaic_search_box_get_text (MosaicSearchBox *box);
43 | void mosaic_search_box_append_text (MosaicSearchBox *box, const gchar *text);
44 | void mosaic_search_box_remove_symbols (MosaicSearchBox *box, guint size);
45 | void mosaic_search_box_kill_word (MosaicSearchBox *box);
46 | 
47 | G_END_DECLS
48 | 
49 | #endif /* MOSAIC_SEARCH_BOX_H */
50 | 


--------------------------------------------------------------------------------
/src/mosaic_window_box.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (c) 2012, Anton S. Lobashev
  2 |  * mosaic_window_box.c - window box widget.
  3 |  */
  4 | 
  5 | #include "mosaic_window_box.h"
  6 | 
  7 | enum {
  8 |   PROP_0,
  9 |   PROP_IS_WINDOW,
 10 |   PROP_XWINDOW,
 11 |   PROP_NAME,
 12 |   PROP_OPT_NAME,
 13 |   N_PROPERTIES
 14 | };
 15 | 
 16 | static GObject*	mosaic_window_box_constructor (GType gtype,
 17 | 					       guint n_properties,
 18 | 					       GObjectConstructParam *properties);
 19 | static void mosaic_window_box_dispose (GObject *gobject);
 20 | static void mosaic_window_box_set_property (GObject *gobject,
 21 | 					    guint prop_id,
 22 | 					    const GValue *value,
 23 | 					    GParamSpec *pspec);
 24 | static void mosaic_window_box_get_property (GObject *gobject,
 25 | 					    guint prop_id,
 26 | 					    GValue *value,
 27 | 					    GParamSpec *pspec);
 28 | 
 29 | static gboolean mosaic_window_box_expose_event (GtkWidget *widget, GdkEventExpose *event);
 30 | static void mosaic_window_box_paint (MosaicWindowBox *box, cairo_t *cr, gint width, gint height);
 31 | static void mosaic_window_box_create_colors (MosaicWindowBox *box);
 32 | static void mosaic_window_box_setup_icon (MosaicWindowBox *box, GdkPixbuf *pixbuf);
 33 | 
 34 | static GParamSpec *obj_properties[N_PROPERTIES] = { NULL };
 35 | 
 36 | G_DEFINE_TYPE (MosaicWindowBox, mosaic_window_box, MOSAIC_TYPE_BOX);
 37 | 
 38 | static void
 39 | mosaic_window_box_class_init (MosaicWindowBoxClass *klass)
 40 | {
 41 |   GObjectClass *gobject_class;
 42 |   GtkWidgetClass *widget_class;
 43 | 
 44 |   gobject_class = G_OBJECT_CLASS (klass);
 45 |   widget_class = GTK_WIDGET_CLASS (klass);
 46 | 
 47 |   gobject_class->constructor = mosaic_window_box_constructor;
 48 |   gobject_class->dispose = mosaic_window_box_dispose;
 49 |   gobject_class->set_property = mosaic_window_box_set_property;
 50 |   gobject_class->get_property = mosaic_window_box_get_property;
 51 | 
 52 |   widget_class->expose_event = mosaic_window_box_expose_event;
 53 | 
 54 |   obj_properties[PROP_IS_WINDOW] =
 55 |     g_param_spec_boolean ("is-window",
 56 | 			  "Is window",
 57 | 			  "If set, the box stores XWindow information",
 58 | 			  FALSE,
 59 | 			  G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
 60 | 
 61 | #ifdef X11
 62 |   obj_properties[PROP_XWINDOW] =
 63 |     g_param_spec_uint ("xwindow",
 64 | 		       "XWindow",
 65 | 		       "XWindow ID",
 66 | 		       0, G_MAXUINT,
 67 | 		       0,
 68 | 		       G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
 69 | #endif
 70 | 
 71 | #ifdef WIN32
 72 |   obj_properties[PROP_XWINDOW] =
 73 |     g_param_spec_pointer ("xwindow",
 74 | 		       "Window handler",
 75 | 		       "Actually HWND pointer.",
 76 | 		       G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
 77 | #endif
 78 | 
 79 |   obj_properties[PROP_NAME] =
 80 |     g_param_spec_string ("name",
 81 | 			 "Name in the box",
 82 | 			 "Name displayed in the box",
 83 | 			 NULL,
 84 | 			 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
 85 | 
 86 |   obj_properties[PROP_OPT_NAME] =
 87 |     g_param_spec_string ("opt_name",
 88 | 			 "WM_CLASS",
 89 | 			 "Class of the XWindow",
 90 | 			 NULL,
 91 | 			 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
 92 | 
 93 |   g_object_class_install_property (gobject_class, PROP_IS_WINDOW, obj_properties [PROP_IS_WINDOW]);
 94 |   g_object_class_install_property (gobject_class, PROP_XWINDOW, obj_properties [PROP_XWINDOW]);
 95 |   g_object_class_install_property (gobject_class, PROP_NAME, obj_properties [PROP_NAME]);
 96 |   g_object_class_install_property (gobject_class, PROP_OPT_NAME, obj_properties [PROP_OPT_NAME]);
 97 | }
 98 | 
 99 | static void
100 | mosaic_window_box_init (MosaicWindowBox *box)
101 | {
102 |   gtk_widget_set_can_focus (GTK_WIDGET (box), TRUE);
103 |   gtk_widget_set_receives_default (GTK_WIDGET (box), TRUE);
104 | 
105 |   box->opt_name = NULL;
106 |   box->icon_pixbuf = NULL;
107 |   box->icon_surface = NULL;
108 |   box->icon_context = NULL;
109 |   box->desktop = -1;
110 | }
111 | 
112 | static GObject*	mosaic_window_box_constructor (GType gtype,
113 | 					guint n_properties,
114 | 					GObjectConstructParam *properties)
115 | {
116 |   GObject *obj;
117 |   MosaicWindowBox *box;
118 | 
119 |   obj = G_OBJECT_CLASS (mosaic_window_box_parent_class)->constructor (gtype, n_properties, properties);
120 | 
121 |   box = MOSAIC_WINDOW_BOX (obj);
122 | 
123 |   if (box->is_window) {
124 |     MOSAIC_BOX (box)->name = get_window_name (box->xwindow);
125 |     box->opt_name = get_window_class (box->xwindow);
126 | #ifdef X11
127 |     box->desktop = get_window_desktop (box->xwindow);
128 | #endif
129 |   }
130 |   box->show_desktop = FALSE;
131 |   box->show_titles = TRUE;
132 |   box->has_icon = FALSE;
133 |   box->colorize = TRUE;
134 |   box->color_offset = 0;
135 |   mosaic_window_box_create_colors (box);
136 | 
137 |   return obj;
138 | }
139 | 
140 | GtkWidget* mosaic_window_box_new (void)
141 | {
142 |   return g_object_new (MOSAIC_TYPE_WINDOW_BOX, "is-window", FALSE, NULL);
143 | }
144 | 
145 | GtkWidget* mosaic_window_box_new_with_xwindow (Window win)
146 | {
147 |   return g_object_new (MOSAIC_TYPE_WINDOW_BOX, "is-window", TRUE, "xwindow", win, NULL);
148 | }
149 | 
150 | GtkWidget* mosaic_window_box_new_with_name (gchar *name)
151 | {
152 |   return g_object_new (MOSAIC_TYPE_WINDOW_BOX, "is-window", FALSE, "name", name, NULL);
153 | }
154 | 
155 | static void
156 | mosaic_window_box_dispose (GObject *gobject)
157 | {
158 |   MosaicWindowBox *box = MOSAIC_WINDOW_BOX (gobject);
159 | 
160 |   if (box->opt_name)
161 |     g_free (box->opt_name);
162 |   box->opt_name = NULL;
163 | 
164 |   if (box->icon_context) {
165 |     cairo_destroy (box->icon_context);
166 |     cairo_surface_destroy (box->icon_surface);
167 |     box->icon_context = NULL;
168 |     box->icon_surface = NULL;
169 |   }
170 |   if (box->icon_pixbuf)
171 |     g_object_unref (box->icon_pixbuf);
172 |   box->icon_pixbuf = NULL;
173 | 
174 |   G_OBJECT_CLASS (mosaic_window_box_parent_class)->dispose (gobject);
175 | }
176 | 
177 | static void mosaic_window_box_set_property (GObject *gobject,
178 | 					    guint prop_id,
179 | 					    const GValue *value,
180 | 					    GParamSpec *pspec)
181 | {
182 |   MosaicWindowBox *box = MOSAIC_WINDOW_BOX (gobject);
183 | 
184 |   switch (prop_id) {
185 |   case PROP_IS_WINDOW:
186 |     mosaic_window_box_set_is_window (box, g_value_get_boolean (value));
187 |     break;
188 |   case PROP_XWINDOW:
189 | #ifdef X11
190 |     mosaic_window_box_set_xwindow (box, g_value_get_uint (value));
191 | #endif
192 | #ifdef WIN32
193 |     mosaic_window_box_set_xwindow (box, g_value_get_pointer(value));
194 | #endif
195 |     break;
196 |   case PROP_NAME:
197 |     mosaic_window_box_set_name (box, g_value_get_string (value));
198 |     break;
199 |   case PROP_OPT_NAME:
200 |     mosaic_window_box_set_opt_name (box, g_value_get_string (value));
201 |     break;
202 |   default:
203 |     G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
204 |     break;
205 |   }
206 | }
207 | 
208 | static void mosaic_window_box_get_property (GObject *gobject,
209 | 					    guint prop_id,
210 | 					    GValue *value,
211 | 					    GParamSpec *pspec)
212 | {
213 |   MosaicWindowBox *box = MOSAIC_WINDOW_BOX (gobject);
214 | 
215 |   switch (prop_id) {
216 |   case PROP_IS_WINDOW:
217 |     g_value_set_boolean (value, box->is_window);
218 |     break;
219 |   case PROP_XWINDOW:
220 | #ifdef X11
221 |     g_value_set_uint (value, box->xwindow);
222 | #endif
223 | #ifdef WIN32
224 |     g_value_set_pointer (value, box->xwindow);
225 | #endif
226 |     break;
227 |   case PROP_NAME:
228 |     g_value_set_string (value, MOSAIC_BOX(box)->name);
229 |     break;
230 |   case PROP_OPT_NAME:
231 |     g_value_set_string (value, box->opt_name);
232 |     break;
233 |   default:
234 |     G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
235 |     break;
236 |   }
237 | }
238 | 
239 | static gboolean
240 | mosaic_window_box_expose_event (GtkWidget *widget, GdkEventExpose *event)
241 | {
242 |   g_return_val_if_fail (MOSAIC_IS_WINDOW_BOX (widget), FALSE);
243 | 
244 |   cairo_t *cr;
245 |   cr = gdk_cairo_create (widget->window);
246 |   cairo_rectangle (cr,
247 | 		   event->area.x, event->area.y,
248 | 		   event->area.width, event->area.height);
249 |   cairo_clip (cr);
250 |   mosaic_window_box_paint (MOSAIC_WINDOW_BOX (widget), cr, widget->allocation.width, widget->allocation.height);
251 |   cairo_destroy (cr);
252 |   return TRUE;
253 | }
254 | 
255 | static void
256 | mosaic_window_box_paint (MosaicWindowBox *box, cairo_t *cr, gint width, gint height)
257 | {
258 |   gboolean has_focus = gtk_widget_has_focus (GTK_WIDGET (box));
259 |   if (MOSAIC_BOX (box)->on_box)
260 |     cairo_set_source_rgb (cr, box->r-0.2, box->g-0.2, box->b-0.2);
261 |   else if (has_focus)
262 |     cairo_set_source_rgb (cr, box->r-0.4, box->g-0.4, box->b-0.4);
263 |   else
264 |     cairo_set_source_rgb (cr, box->r, box->g, box->b);
265 |   cairo_rectangle (cr, 0, 0, width, height);
266 |   cairo_fill (cr);
267 | 
268 |   PangoLayout *pl;
269 |   PangoFontDescription *pfd;
270 |   pl = pango_cairo_create_layout (cr);
271 | 
272 |   /* Shall we draw the desktop number */
273 |   if (box->show_desktop) {
274 |     gchar desk [4] = { 0 };
275 |     if (box->desktop > -1)
276 |       sprintf (desk, "%d", box->desktop+1);
277 |     else
278 |       sprintf (desk, "A");
279 | 
280 |     pango_layout_set_text (pl, desk, -1);
281 |     pfd = pango_font_description_from_string (MOSAIC_BOX (box)->font);
282 |     pango_font_description_set_weight (pfd, PANGO_WEIGHT_BOLD);
283 |     pango_font_description_set_size (pfd, (height-10) * PANGO_SCALE);
284 |     pango_layout_set_font_description (pl, pfd);
285 |     pango_font_description_free (pfd);
286 | 
287 |     if (has_focus)
288 |       cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.5);
289 |     else
290 |       cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.5);
291 | 
292 |     int pwidth, pheight;
293 |     pango_layout_get_pixel_size (pl, &pwidth, &pheight);
294 | 
295 |     cairo_move_to (cr, (width - pwidth)/2, (height - pheight)/2);
296 |     pango_cairo_show_layout (cr, pl);
297 |   }
298 | 
299 |   gint text_offset = 0;
300 | 
301 |   if (box->has_icon) {
302 |     if (box->icon_pixbuf) {
303 |       guint iwidth = gdk_pixbuf_get_width (box->icon_pixbuf);
304 |       guint iheight = gdk_pixbuf_get_height (box->icon_pixbuf);
305 |       cairo_save (cr);
306 |       cairo_set_source_surface (cr, box->icon_surface, 5, (height-iheight)/2);
307 |       cairo_rectangle (cr, 0, 0,
308 | 		       iwidth+5,
309 | 		       (height+iheight)/2);
310 |       cairo_clip (cr);
311 |       cairo_paint (cr);
312 |       cairo_restore (cr);
313 | 
314 |       text_offset = iwidth+5;
315 |       pango_layout_set_width (pl, (width-iwidth-15) * PANGO_SCALE);
316 |     }
317 |   } else {
318 |     pango_layout_set_width (pl, (width-15) * PANGO_SCALE);
319 |   }
320 | 
321 |   // Draw name.
322 |   if (box->show_titles) {
323 |     pango_layout_set_ellipsize (pl, PANGO_ELLIPSIZE_END);
324 |     pango_layout_set_text (pl, MOSAIC_BOX (box)->name, -1);
325 |     pfd = pango_font_description_from_string (MOSAIC_BOX (box)->font);
326 |     pango_layout_set_font_description (pl, pfd);
327 |     pango_font_description_free (pfd);
328 | 
329 |     int pwidth, pheight;
330 |     pango_layout_get_pixel_size (pl, &pwidth, &pheight);
331 | 
332 |     if (has_focus)
333 |       cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 1.0);
334 |     else
335 |       cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0);
336 | 
337 |     if (text_offset > 0) {
338 |       if ((width-pwidth)/2 > text_offset+5)
339 | 	cairo_move_to (cr, (width - pwidth)/2, (height - pheight)/2);
340 |       else
341 | 	cairo_move_to (cr, text_offset+5, (height - pheight)/2);
342 |     } else {
343 |       if (width-5 > pwidth)
344 | 	cairo_move_to (cr, (width - pwidth)/2, (height - pheight)/2);
345 |       else
346 | 	cairo_move_to (cr, 5, (height - pheight)/2);
347 |     }
348 | 
349 |     pango_cairo_show_layout (cr, pl);
350 |   }
351 |   g_object_unref (pl);
352 | 
353 |   mosaic_box_paint (MOSAIC_BOX (box), cr, width, height);
354 | }
355 | 
356 | void
357 | mosaic_window_box_set_is_window (MosaicWindowBox *box, gboolean is_window)
358 | {
359 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
360 | 
361 |   box->is_window = is_window;
362 | 
363 |   g_object_notify (G_OBJECT (box), "is-window");
364 | }
365 | 
366 | gboolean
367 | mosaic_window_box_get_is_window (MosaicWindowBox *box)
368 | {
369 |   g_return_val_if_fail (MOSAIC_IS_WINDOW_BOX (box), FALSE);
370 | 
371 |   return box->is_window;
372 | }
373 | 
374 | void mosaic_window_box_set_xwindow (MosaicWindowBox *box, Window window)
375 | {
376 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
377 | 
378 |   if (box->is_window) {
379 |     box->xwindow = window;
380 | 
381 |     g_object_notify (G_OBJECT (box), "xwindow");
382 | #ifdef X11
383 |     box->desktop = get_window_desktop (box->xwindow);
384 | #endif
385 |     mosaic_window_box_update_xwindow_name (box);
386 |     mosaic_window_box_update_opt_name (box);
387 |   }
388 | }
389 | 
390 | Window mosaic_window_box_get_xwindow (MosaicWindowBox *box)
391 | {
392 |   g_return_val_if_fail (MOSAIC_IS_WINDOW_BOX (box), 0);
393 | 
394 |   return box->xwindow;
395 | }
396 | 
397 | void
398 | mosaic_window_box_set_name (MosaicWindowBox *box, const gchar *name)
399 | {
400 |   mosaic_box_set_name (MOSAIC_BOX (box), name);
401 | }
402 | 
403 | const gchar *
404 | mosaic_window_box_get_name (MosaicWindowBox *box)
405 | {
406 |   g_return_val_if_fail (MOSAIC_IS_WINDOW_BOX (box), NULL);
407 | 
408 |   return MOSAIC_BOX (box)->name;
409 | }
410 | 
411 | void
412 | mosaic_window_box_set_opt_name (MosaicWindowBox *box, const gchar *opt_name)
413 | {
414 |   gchar *new_opt_name;
415 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
416 | 
417 |   new_opt_name = g_strdup (opt_name);
418 |   g_free (box->opt_name);
419 |   box->opt_name = new_opt_name;
420 | 
421 |   g_object_notify (G_OBJECT (box), "opt_name");
422 |   mosaic_window_box_create_colors (box);
423 |   gtk_widget_queue_draw (GTK_WIDGET (box));
424 | }
425 | 
426 | const gchar *
427 | mosaic_window_box_get_opt_name (MosaicWindowBox *box)
428 | {
429 |   g_return_val_if_fail (MOSAIC_IS_WINDOW_BOX (box), NULL);
430 | 
431 |   return box->opt_name;
432 | }
433 | 
434 | void mosaic_window_box_update_xwindow_name (MosaicWindowBox *box)
435 | {
436 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
437 | 
438 |   if (box->is_window) {
439 |     gchar *wname = get_window_name (box->xwindow);
440 |     mosaic_window_box_set_name (box, wname);
441 |     g_free (wname);
442 |   }
443 | 
444 |   if (gtk_widget_get_has_tooltip(GTK_WIDGET(box)))
445 |     gtk_widget_set_tooltip_text (GTK_WIDGET(box), MOSAIC_BOX(box)->name);
446 | }
447 | 
448 | void mosaic_window_box_update_opt_name (MosaicWindowBox *box)
449 | {
450 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
451 | 
452 |   if (box->is_window) {
453 |     gchar *opt_name = get_window_class (box->xwindow);
454 |     mosaic_window_box_set_opt_name (box, opt_name);
455 |     g_free (opt_name);
456 |   }
457 | }
458 | 
459 | gint mosaic_window_box_get_desktop (MosaicWindowBox *box)
460 | {
461 |   g_return_val_if_fail (MOSAIC_IS_WINDOW_BOX (box), -1);
462 | 
463 |   return box->desktop;
464 | }
465 | 
466 | void mosaic_window_box_set_desktop (MosaicWindowBox *box, gint desktop)
467 | {
468 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
469 | 
470 |   box->desktop = desktop;
471 | }
472 | 
473 | static gushort get_crc16 (gchar *octets, guint len)
474 | {
475 |   gushort crc16_poly = 0x8408;
476 | 
477 |   gushort data;
478 |   gushort crc = 0xffff;
479 |   if (len == 0)
480 |     return (~crc);
481 | 
482 |   do {
483 |     for (int i =0, data= (guint)0xff & *octets++;
484 | 	 i < 8;
485 | 	 i++, data >>= 1) {
486 |       if ((crc & 0x0001) ^ (data & 0x0001))
487 | 	crc = (crc >> 1) ^ crc16_poly;
488 |       else
489 | 	crc >>= 1;
490 |     }
491 |   } while (--len);
492 | 
493 |   crc = ~crc;
494 |   data = crc;
495 |   crc = (crc << 8) | (data >> 8 & 0xff);
496 | 
497 |   return (crc);
498 | }
499 | 
500 | static gdouble hue2rgb (gdouble p, gdouble q, gdouble t)
501 | {
502 |   if (t < 0.0)
503 |     t += 1.0;
504 |   if (t > 1.0)
505 |     t -= 1.0;
506 |   if (t < 1.0/6.0)
507 |     return (p + (q - p) * 6.0 * t);
508 |   if (t < 1.0/2.0)
509 |     return q;
510 |   if (t < 2.0/3.0)
511 |     return (p + (q - p) * (2.0/3.0 - t) * 6.0);
512 |   return p;
513 | }
514 | 
515 | static void mosaic_window_box_create_colors (MosaicWindowBox *box)
516 | {
517 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
518 | 
519 |   gchar *source = (box->opt_name) ? box->opt_name : MOSAIC_BOX (box)->name;
520 |   if (box->colorize && source) {
521 |     gdouble h, s, l;
522 |     gulong crc = get_crc16 (source, strlen (source));
523 |     guchar pre_h = (((crc >> 8) & 0xFF) + box->color_offset) % 256;
524 |     guchar pre_s = ((crc << 0) & 0xFF);
525 |     h = pre_h / 255.0;
526 |     s = 0.5 + pre_s / 512.0;
527 |     l = 0.6;
528 | 
529 |     gdouble q = l < 0.5 ? l * (1.0 + s) : l + s - l * s;
530 |     gdouble p = 2.0 * l - q;
531 |     box->r = hue2rgb (p, q, h + 1.0/3.0);
532 |     box->g = hue2rgb (p, q, h);
533 |     box->b = hue2rgb (p, q, h - 1.0/3.0);
534 |   } else {
535 |     box->r = box->g = box->b = 0.6;
536 |   }
537 | }
538 | 
539 | void mosaic_window_box_setup_icon_from_wm (MosaicWindowBox *box, guint req_width, guint req_height)
540 | {
541 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
542 | 
543 |   GdkPixbuf *pixbuf = get_window_icon (box->xwindow, req_width, req_height);
544 |   if (!pixbuf) {
545 |     // Try to load fallback icon.
546 |     gchar *class1 = g_ascii_strdown (box->opt_name, -1);
547 |     gchar *class2 = g_ascii_strdown (box->opt_name+strlen (class1)+1, -1);
548 | 
549 |     GtkIconTheme *theme = gtk_icon_theme_get_default ();
550 |     pixbuf = gtk_icon_theme_load_icon (theme, class1, req_width,
551 | 				       GTK_ICON_LOOKUP_USE_BUILTIN |
552 | 				       GTK_ICON_LOOKUP_GENERIC_FALLBACK,
553 | 				       NULL);
554 | 
555 |     if (!pixbuf)
556 |       pixbuf = gtk_icon_theme_load_icon (theme, class2, req_width,
557 | 					 GTK_ICON_LOOKUP_USE_BUILTIN |
558 | 					 GTK_ICON_LOOKUP_GENERIC_FALLBACK,
559 | 					 NULL);
560 | 
561 |     if (!pixbuf)
562 |       pixbuf = gtk_icon_theme_load_icon (theme, "application-x-executable", req_width,
563 | 					 GTK_ICON_LOOKUP_USE_BUILTIN |
564 | 					 GTK_ICON_LOOKUP_GENERIC_FALLBACK,
565 | 					 NULL);
566 |     g_free (class1);
567 |     g_free (class2);
568 |   }
569 |   if (!pixbuf) {
570 |     box->has_icon = FALSE;
571 |     return;
572 |   }
573 | 
574 |   mosaic_window_box_setup_icon (box, pixbuf);
575 | }
576 | 
577 | void mosaic_window_box_setup_icon_from_theme (MosaicWindowBox *box, const gchar *name, guint req_width, guint req_height)
578 | {
579 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
580 | 
581 |   GtkIconTheme *theme = gtk_icon_theme_get_default ();
582 |   GdkPixbuf *pixbuf = gtk_icon_theme_load_icon (theme, name, req_width,
583 | 				     GTK_ICON_LOOKUP_USE_BUILTIN |
584 | 				     GTK_ICON_LOOKUP_GENERIC_FALLBACK,
585 | 				     NULL);
586 | 
587 |   if (!pixbuf) {
588 |     box->has_icon = FALSE;
589 |     return;
590 |   }
591 | 
592 |   mosaic_window_box_setup_icon (box, pixbuf);
593 | }
594 | 
595 | void mosaic_window_box_setup_icon_from_file (MosaicWindowBox *box, const gchar *file, guint req_width, guint req_height)
596 | {
597 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
598 | 
599 |   GError *error = NULL;
600 |   GdkPixbuf *pixbuf;
601 |   
602 |   if(!(pixbuf = gdk_pixbuf_new_from_file_at_size (file, req_width, req_height, &error)))
603 |     g_printerr("%s\n", error->message);
604 | 
605 |   if (!pixbuf) {
606 |     box->has_icon = FALSE;
607 |     return;
608 |   }
609 | 
610 |   mosaic_window_box_setup_icon (box, pixbuf);
611 | }
612 | 
613 | static void mosaic_window_box_setup_icon (MosaicWindowBox *box, GdkPixbuf *pixbuf)
614 | {
615 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
616 | 
617 |   if (box->icon_pixbuf)
618 |     g_object_unref (box->icon_pixbuf);
619 |   if (box->icon_surface)
620 |     cairo_surface_destroy (box->icon_surface);
621 |   if (box->icon_context)
622 |     cairo_destroy (box->icon_context);
623 | 
624 |   if (pixbuf) {
625 |     box->icon_pixbuf = pixbuf;
626 | 
627 |     box->has_icon = TRUE;
628 |     box->icon_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
629 | 						    gdk_pixbuf_get_width (box->icon_pixbuf),
630 | 						    gdk_pixbuf_get_height (box->icon_pixbuf));
631 |     box->icon_context = cairo_create (box->icon_surface);
632 |     gdk_cairo_set_source_pixbuf (box->icon_context, box->icon_pixbuf, 0, 0);
633 |     cairo_paint (box->icon_context);
634 |   } else {
635 |     box->has_icon = FALSE;
636 |   }
637 | }
638 | 
639 | void mosaic_window_box_set_colorize (MosaicWindowBox *box, gboolean colorize)
640 | {
641 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
642 | 
643 |   box->colorize = colorize;
644 |   mosaic_window_box_create_colors (box);
645 | }
646 | 
647 | void mosaic_window_box_set_show_desktop (MosaicWindowBox *box, gboolean show_desktop)
648 | {
649 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
650 | 
651 |   box->show_desktop = show_desktop;
652 | }
653 | 
654 | void mosaic_window_box_set_show_titles (MosaicWindowBox *box, gboolean show_titles)
655 | {
656 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
657 | 
658 |   box->show_titles = show_titles;
659 |   if (!show_titles)
660 |     gtk_widget_set_tooltip_text (GTK_WIDGET(box), MOSAIC_BOX(box)->name);
661 | }
662 | 
663 | void mosaic_window_box_set_color_offset (MosaicWindowBox *box, guchar color_offset)
664 | {
665 |   g_return_if_fail (MOSAIC_IS_WINDOW_BOX (box));
666 | 
667 |   box->color_offset = color_offset;
668 |   mosaic_window_box_create_colors (box);
669 | }
670 | 
671 | void mosaic_window_box_set_color_from_string (MosaicWindowBox *box, const gchar *color)
672 | {
673 |   gchar *scolor = g_strdup (color);
674 |   g_strstrip (scolor);
675 |   int parsed = 0x888888;
676 |   if (g_str_has_prefix (scolor, "#"))
677 |     parsed = strtol (scolor+1, NULL, 16);
678 |   guchar r = (parsed >> 16) & 0xff;
679 |   guchar g = (parsed >> 8) & 0xff;
680 |   guchar b = (parsed >> 0) & 0xff;
681 | 
682 |   box->r = r / 255.0;
683 |   box->g = g / 255.0;
684 |   box->b = b / 255.0;
685 | 
686 |   g_free (scolor);
687 | }
688 | 


--------------------------------------------------------------------------------
/src/mosaic_window_box.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (c) 2012, Anton S. Lobashev
 2 |  * mosaic_window_box.h - headers for window box widget
 3 |  */
 4 | 
 5 | #ifndef MOSAIC_WINDOW_BOX_H
 6 | #define MOSAIC_WINDOW_BOX_H
 7 | 
 8 | #include <stdlib.h>
 9 | #include <gtk/gtk.h>
10 | #include <cairo.h>
11 | #include <gdk/gdkkeysyms.h>
12 | #include <string.h>
13 | #include "mosaic_box.h"
14 | #ifdef X11
15 | #include "x_interaction.h"
16 | #endif
17 | #ifdef WIN32
18 | #include "win32_interaction.h"
19 | #endif
20 | 
21 | G_BEGIN_DECLS
22 | 
23 | #define MOSAIC_TYPE_WINDOW_BOX            (mosaic_window_box_get_type ())
24 | #define MOSAIC_WINDOW_BOX(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MOSAIC_TYPE_WINDOW_BOX, MosaicWindowBox))
25 | #define MOSAIC_WINDOW_BOX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MOSAIC_TYPE_WINDOW_BOX, MosaicWindowBoxClass))
26 | #define MOSAIC_IS_WINDOW_BOX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MOSAIC_TYPE_WINDOW_BOX))
27 | #define MOSAIC_IS_WINDOW_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOSAIC_TYPE_WINDOW_BOX))
28 | #define MOSAIC_WINDOW_BOX_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MOSAIC_TYPE_WINDOW_BOX, MosaicWindowBoxClass))
29 | 
30 | typedef struct _MosaicWindowBox      MosaicWindowBox;
31 | typedef struct _MosaicWindowBoxClass MosaicWindowBoxClass;
32 | 
33 | struct _MosaicWindowBox
34 | {
35 |   MosaicBox parent;
36 | 
37 |   /*< private >*/
38 |   gboolean is_window;
39 |   Window xwindow;
40 | 
41 |   gchar *opt_name;
42 |   gboolean show_desktop;
43 |   gboolean show_titles;
44 |   gint desktop;
45 | 
46 |   gboolean colorize;
47 |   gdouble r, g, b;
48 |   guchar color_offset;
49 | 
50 |   gboolean has_icon;
51 |   GdkPixbuf *icon_pixbuf;
52 |   cairo_t *icon_context;
53 |   cairo_surface_t *icon_surface;
54 | };
55 | 
56 | struct _MosaicWindowBoxClass
57 | {
58 |   MosaicBoxClass parent_class;
59 | 
60 |   void (* pressed)  (MosaicWindowBox *box);
61 |   void (* released) (MosaicWindowBox *box);
62 |   void (* clicked)  (MosaicWindowBox *box);
63 |   void (* enter)    (MosaicWindowBox *box);
64 |   void (* leave)    (MosaicWindowBox *box);
65 |   void (* activate) (MosaicWindowBox *box);
66 | };
67 | 
68 | GType mosaic_window_box_get_type (void);
69 | GtkWidget* mosaic_window_box_new (void);
70 | GtkWidget* mosaic_window_box_new_with_xwindow (Window win);
71 | GtkWidget* mosaic_window_box_new_with_name (gchar *name);
72 | void mosaic_window_box_set_is_window (MosaicWindowBox *box, gboolean is_window);
73 | gboolean mosaic_window_box_get_is_window (MosaicWindowBox *box);
74 | void mosaic_window_box_set_xwindow (MosaicWindowBox *box, Window window);
75 | Window mosaic_window_box_get_xwindow (MosaicWindowBox *box);
76 | void mosaic_window_box_set_name (MosaicWindowBox *box, const gchar *name);
77 | const gchar *mosaic_window_box_get_name (MosaicWindowBox *box);
78 | void mosaic_window_box_set_opt_name (MosaicWindowBox *box, const gchar *opt_name);
79 | const gchar *mosaic_window_box_get_opt_name (MosaicWindowBox *box);
80 | void mosaic_window_box_update_xwindow_name (MosaicWindowBox *box);
81 | void mosaic_window_box_update_opt_name (MosaicWindowBox *box);
82 | void mosaic_window_box_setup_icon_from_wm (MosaicWindowBox *box, guint req_width, guint req_height);
83 | void mosaic_window_box_setup_icon_from_theme (MosaicWindowBox *box, const gchar *name, guint req_width, guint req_height);
84 | void mosaic_window_box_setup_icon_from_file (MosaicWindowBox *box, const gchar *file, guint req_width, guint req_height);
85 | void mosaic_window_box_set_colorize (MosaicWindowBox *box, gboolean colorize);
86 | void mosaic_window_box_set_show_desktop (MosaicWindowBox *box, gboolean show_desktop);
87 | void mosaic_window_box_set_show_titles (MosaicWindowBox *box, gboolean show_titles);
88 | void mosaic_window_box_set_color_offset (MosaicWindowBox *box, guchar color_offset);
89 | void mosaic_window_box_set_color_from_string (MosaicWindowBox *box, const gchar *color);
90 | gint mosaic_window_box_get_desktop (MosaicWindowBox *box);
91 | void mosaic_window_box_set_desktop (MosaicWindowBox *box, gint desktop);
92 | 
93 | G_END_DECLS
94 | 
95 | #endif /* MOSAIC_WINDOW_BOX_H */
96 | 


--------------------------------------------------------------------------------
/src/win32_interaction.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (c) 2012, Timur S. Sultanov
  2 |  * win32_interaction.c - layer to talk with WinAPI.
  3 |  */
  4 | 
  5 | #include "win32_interaction.h"
  6 | #include <winuser.h>
  7 | #include <winable.h>
  8 | 
  9 | static HWND window_list[1024];
 10 | 
 11 | char* get_window_name(HWND win)
 12 | {
 13 |   TCHAR title[256];
 14 |   GetWindowText(win, title, 255);
 15 |   return g_locale_to_utf8(title, lstrlen(title), NULL, NULL, NULL);
 16 | }
 17 | 
 18 | char* get_window_class(HWND win)
 19 | {
 20 |   TCHAR class[256];
 21 |   RealGetWindowClass(win, class, 255);
 22 |   return g_locale_to_utf8(class, lstrlen(class), NULL, NULL, NULL);
 23 | }
 24 | 
 25 | BOOL CALLBACK EnumWindowsProc(
 26 |   HWND hwnd,
 27 |   LPARAM num
 28 | )
 29 | {
 30 |   WINDOWINFO pwi;
 31 |   pwi.cbSize = sizeof(WINDOWINFO);
 32 |   GetWindowInfo(hwnd, &pwi);
 33 | if ((pwi.dwStyle & WS_VISIBLE) && !(pwi.dwStyle & WS_DISABLED) && (pwi.dwStyle & WS_SYSMENU))
 34 | {
 35 |     if(g_strcmp0(get_window_name(hwnd), "XWinMosaic")){
 36 |         window_list[(*((int*)num))++] = hwnd;
 37 |     }
 38 |   }
 39 |   return 1;
 40 | }
 41 | 
 42 | HWND* get_windows_list()
 43 | {
 44 |   int num = 0;
 45 |   EnumWindows(EnumWindowsProc, (LPARAM)&num);
 46 |   window_list[num] = NULL;
 47 |   return window_list;
 48 | }
 49 | 
 50 | gboolean already_opened()
 51 | {
 52 |   gboolean opened = FALSE;
 53 |   HWND *win_list = get_windows_list();
 54 |   while(*win_list++)
 55 |   {
 56 |     gchar* wmclass = get_window_class(*win_list);
 57 |     if(wmclass && !g_strcmp0(wmclass, "xwinmosaic"))
 58 |     {
 59 |       opened = TRUE;
 60 |       break;
 61 |     }
 62 |     if(wmclass)
 63 |       g_free(wmclass);
 64 |   }
 65 |   return opened;
 66 | }
 67 | 
 68 | GdkPixbuf* get_window_icon(HWND win, guint req_width, guint req_height)
 69 | {
 70 |   GdkPixbuf* gicon;
 71 |   HICON icon = (HICON)SendMessage(win,WM_GETICON,(req_width > 16) ? ICON_BIG : ICON_SMALL,0);
 72 |   if(!icon)
 73 |   {
 74 |     icon = (HICON)SendMessage(win,WM_GETICON,ICON_SMALL,0);
 75 |   }
 76 |   if(!icon)
 77 |   {
 78 |     icon = (HICON)GetClassLongPtr(win, GCLP_HICON);
 79 |   }
 80 |   if(!icon)
 81 |   {
 82 |     icon = (HICON)GetClassLongPtr(win, GCLP_HICONSM);
 83 |   }
 84 |   gicon = gdk_win32_icon_to_pixbuf_libgtk_only(icon);
 85 |   if (gdk_pixbuf_get_width (gicon) > req_width)
 86 |     gicon = gdk_pixbuf_scale_simple(gicon, req_width, req_height, GDK_INTERP_BILINEAR);
 87 |   return gicon;
 88 | }
 89 | 
 90 | HWND* sorted_windows_list(HWND *myown, HWND *active_win, int *nitems, gboolean only_current)
 91 | {
 92 |   // XXX: Ignoring only_current for now.
 93 |   WINDOWINFO pwi;
 94 |   HWND* pre_win_list = get_windows_list();
 95 |   int size = 0;
 96 |   while(*(pre_win_list + size)) {
 97 |     GetWindowInfo(*(pre_win_list + size), &pwi);
 98 | #ifdef DEBUG
 99 |     g_printerr ("%s, %s, %x\n", get_window_name(*(pre_win_list + size)),
100 |            get_window_class(*(pre_win_list + size)),
101 |            pwi.dwStyle);
102 | #endif
103 |     size++;
104 |   }
105 |   *nitems = size;
106 |   myown = pre_win_list;
107 |   active_win = pre_win_list+1;
108 |   return pre_win_list;
109 | }
110 | 
111 | void switch_to_window(HWND win)
112 | {
113 |   WINDOWPLACEMENT wp;
114 |   wp.length = sizeof(WINDOWPLACEMENT);
115 |   GetWindowPlacement(win, &wp);
116 |   if((wp.showCmd == SW_MINIMIZE) || (wp.showCmd == SW_SHOWMINIMIZED) ||
117 |      (wp.showCmd == SW_SHOWMINNOACTIVE))
118 |     ShowWindow(win, SW_RESTORE);
119 |   else
120 |     SetForegroundWindow (win);
121 | }
122 | 
123 | void tab_event (gboolean shift);
124 | 
125 | LRESULT CALLBACK alt_tab_hook (INT nCode, WPARAM wParam, LPARAM lParam)
126 | {
127 |     // By returning a non-zero value from the hook procedure, the
128 |     // message does not get passed to the target window
129 |   KBDLLHOOKSTRUCT *pkbhs = (KBDLLHOOKSTRUCT *) lParam;
130 |   BOOL isShiftPressed = FALSE;
131 |   switch (nCode)
132 |     {
133 |     case HC_ACTION:
134 |       {
135 |         isShiftPressed = GetAsyncKeyState (VK_SHIFT) >> ((sizeof(SHORT) * 8) - 1);
136 | 
137 |         if (pkbhs->vkCode == VK_TAB && pkbhs->flags & LLKHF_ALTDOWN) {
138 |           if (!(pkbhs->flags & LLKHF_UP))
139 |             tab_event(isShiftPressed);
140 |           return 1;
141 |         }
142 |         break;
143 |       }
144 |       
145 |     default:
146 |       break;
147 |     }
148 |   return CallNextHookEx (NULL, nCode, wParam, lParam);
149 | }
150 | 
151 | void install_alt_tab_hook ()
152 | {
153 |   if(!SetWindowsHookEx(WH_KEYBOARD_LL, alt_tab_hook, NULL, 0))
154 |     g_printerr("Alt+Tab hook setup failed");
155 | }
156 | 


--------------------------------------------------------------------------------
/src/win32_interaction.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (c) 2012, Timur S. Sultanov
 2 |  * win32_interaction.h - layer to talk with WinAPI.
 3 |  */
 4 | 
 5 | #include <windows.h>
 6 | #include <gdk/gdkwin32.h>
 7 | #include <gtk/gtk.h>
 8 | #include <inttypes.h>
 9 | #include <string.h>
10 | #include <stdlib.h>
11 | #include <tchar.h>
12 | 
13 | #ifndef WIN32_INTERACTION_H
14 | #define WIN32_INTERACTION_H
15 | 
16 | #define Window HWND
17 | 
18 | char *get_window_name(HWND win);
19 | char *get_window_class(HWND win);
20 | HWND* sorted_windows_list(HWND *myown, HWND *active_win, int *nitems, gboolean only_current);
21 | void switch_to_window(HWND win);
22 | GdkPixbuf* get_window_icon(HWND win, guint req_width, guint req_height);
23 | 
24 | gboolean already_opened ();
25 | 
26 | HWND* get_windows_list();
27 | 
28 | void install_alt_tab_hook ();
29 | 
30 | #endif /* WIN32_INTERACTION_H */
31 | 


--------------------------------------------------------------------------------
/src/x_interaction.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (c) 2012, Anton S. Lobashev
  2 |  * x_interaction.c - layer to talk with X11.
  3 |  */
  4 | 
  5 | #include <stdlib.h>
  6 | #include <string.h>
  7 | #include <inttypes.h>
  8 | #include <gdk/gdkx.h>
  9 | #include <gtk/gtk.h>
 10 | #include "x_interaction.h"
 11 | 
 12 | Atom a_UTF8_STRING;
 13 | 
 14 | Atom a_WM_CLASS;
 15 | Atom a_WM_NAME;
 16 | Atom a_WM_WINDOW_ROLE;
 17 | 
 18 | Atom a_NET_SUPPORTING_WM_CHECK;
 19 | Atom a_NET_CLIENT_LIST;
 20 | Atom a_NET_DESKTOP_VIEWPORT;
 21 | Atom a_NET_CURRENT_DESKTOP;
 22 | Atom a_NET_ACTIVE_WINDOW;
 23 | Atom a_NET_WORKAREA;
 24 | 
 25 | Atom a_NET_WM_DESKTOP;
 26 | Atom a_NET_WM_NAME;
 27 | Atom a_NET_WM_VISIBLE_NAME;
 28 | Atom a_NET_WM_ICON;
 29 | Atom a_NET_WM_USER_TIME;
 30 | 
 31 | Atom a_NET_WM_WINDOW_TYPE;
 32 | 
 33 | Atom a_NET_WM_WINDOW_TYPE_DESKTOP;
 34 | Atom a_NET_WM_WINDOW_TYPE_DOCK;
 35 | Atom a_NET_WM_WINDOW_TYPE_TOOLBAR;
 36 | Atom a_NET_WM_WINDOW_TYPE_MENU;
 37 | Atom a_NET_WM_WINDOW_TYPE_UTILITY;
 38 | Atom a_NET_WM_WINDOW_TYPE_SPLASH;
 39 | Atom a_NET_WM_WINDOW_TYPE_DIALOG;
 40 | Atom a_NET_WM_WINDOW_TYPE_DROPDOWN_MENU;
 41 | Atom a_NET_WM_WINDOW_TYPE_POPUP_MENU;
 42 | Atom a_NET_WM_WINDOW_TYPE_TOOLTIP;
 43 | Atom a_NET_WM_WINDOW_TYPE_NOTIFICATION;
 44 | Atom a_NET_WM_WINDOW_TYPE_COMBO;
 45 | Atom a_NET_WM_WINDOW_TYPE_DND;
 46 | Atom a_NET_WM_WINDOW_TYPE_NORMAL;
 47 | 
 48 | Atom a_NET_WM_STATE;
 49 | Atom a_NET_WM_STATE_SKIP_TASKBAR;
 50 | 
 51 | // Initialize Xatoms values.
 52 | void atoms_init ()
 53 | {
 54 |   Display *dpy = (Display *)gdk_x11_get_default_xdisplay ();
 55 | 
 56 |   a_UTF8_STRING = XInternAtom (dpy, "UTF8_STRING", 0);
 57 | 
 58 |   a_WM_CLASS = XInternAtom (dpy, "WM_CLASS", 0);
 59 |   a_WM_NAME = XInternAtom (dpy, "WM_NAME", 0);
 60 |   a_WM_WINDOW_ROLE = XInternAtom (dpy, "WM_WINDOW_ROLE", 0);
 61 | 
 62 |   a_NET_SUPPORTING_WM_CHECK = XInternAtom (dpy, "_NET_SUPPORTING_WM_CHECK", 0);
 63 |   a_NET_CLIENT_LIST = XInternAtom (dpy, "_NET_CLIENT_LIST", 0);
 64 |   a_NET_DESKTOP_VIEWPORT = XInternAtom (dpy, "_NET_DESKTOP_VIEWPORT", 0);
 65 |   a_NET_CURRENT_DESKTOP = XInternAtom (dpy, "_NET_CURRENT_DESKTOP", 0);
 66 |   a_NET_ACTIVE_WINDOW = XInternAtom (dpy, "_NET_ACTIVE_WINDOW", 0);
 67 |   a_NET_WORKAREA = XInternAtom (dpy, "_NET_WORKAREA", 0);
 68 | 
 69 |   a_NET_WM_DESKTOP = XInternAtom (dpy, "_NET_WM_DESKTOP", 0);
 70 |   a_NET_WM_NAME = XInternAtom (dpy, "_NET_WM_NAME", 0);
 71 |   a_NET_WM_VISIBLE_NAME = XInternAtom (dpy, "_NET_WM_VISIBLE_NAME", 0);
 72 |   a_NET_WM_ICON = XInternAtom (dpy, "_NET_WM_ICON", 0);
 73 |   a_NET_WM_USER_TIME = XInternAtom (dpy, "_NET_WM_USER_TIME", 0);
 74 | 
 75 | 
 76 |   a_NET_WM_WINDOW_TYPE = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE", 0);
 77 |   a_NET_WM_WINDOW_TYPE_DESKTOP = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DESKTOP", 0);
 78 |   a_NET_WM_WINDOW_TYPE_DOCK = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DOCK", 0);
 79 |   a_NET_WM_WINDOW_TYPE_TOOLBAR = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_TOOLBAR", 0);
 80 |   a_NET_WM_WINDOW_TYPE_MENU = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_MENU", 0);
 81 |   a_NET_WM_WINDOW_TYPE_UTILITY = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_UTILITY", 0);
 82 |   a_NET_WM_WINDOW_TYPE_SPLASH = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_SPLASH", 0);
 83 |   a_NET_WM_WINDOW_TYPE_DIALOG = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DIALOG", 0);
 84 |   a_NET_WM_WINDOW_TYPE_DROPDOWN_MENU = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", 0);
 85 |   a_NET_WM_WINDOW_TYPE_POPUP_MENU = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_POPUP_MENU", 0);
 86 |   a_NET_WM_WINDOW_TYPE_TOOLTIP = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_TOOLTIP", 0);
 87 |   a_NET_WM_WINDOW_TYPE_NOTIFICATION = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_NOTIFICATION", 0);
 88 |   a_NET_WM_WINDOW_TYPE_COMBO = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_COMBO", 0);
 89 |   a_NET_WM_WINDOW_TYPE_DND = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DND", 0);
 90 |   a_NET_WM_WINDOW_TYPE_NORMAL = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_NORMAL", 0);
 91 | 
 92 |   a_NET_WM_STATE = XInternAtom (dpy, "_NET_WM_STATE", 0);
 93 |   a_NET_WM_STATE_SKIP_TASKBAR = XInternAtom (dpy, "_NET_WM_STATE_SKIP_TASKBAR", 0);
 94 | }
 95 | 
 96 | // Get property for a window.
 97 | void* property (Window win, Atom prop, Atom type, int *nitems)
 98 | {
 99 |   Display *dpy = (Display *)gdk_x11_get_default_xdisplay ();
100 |   Atom type_ret;
101 |   int format_ret;
102 |   unsigned long items_ret;
103 |   unsigned long after_ret;
104 |   unsigned char *prop_data = NULL;
105 | 
106 |   if (Success == XGetWindowProperty (dpy, win, prop, 0, 0xffffffff,
107 | 				    False, type, &type_ret, &format_ret,
108 | 				    &items_ret, &after_ret, &prop_data))
109 |     if (nitems)
110 |       *nitems = items_ret;
111 | 
112 |   return prop_data;
113 | }
114 | 
115 | // Send a message to a window.
116 | void climsg(Window win, long type, long l0, long l1, long l2, long l3, long l4)
117 | {
118 |     XClientMessageEvent xev;
119 | 
120 |     xev.type = ClientMessage;
121 |     xev.window = win;
122 |     xev.message_type = type;
123 |     xev.format = 32;
124 |     xev.data.l[0] = l0;
125 |     xev.data.l[1] = l1;
126 |     xev.data.l[2] = l2;
127 |     xev.data.l[3] = l3;
128 |     xev.data.l[4] = l4;
129 | 
130 |     XSendEvent(gdk_x11_get_default_xdisplay (), gdk_x11_get_default_root_xwindow (), False,
131 |           (SubstructureNotifyMask | SubstructureRedirectMask),
132 |           (XEvent *)&xev);
133 | }
134 | 
135 | // Pretty obvious function name, I think.
136 | int wm_supports_ewmh ()
137 | {
138 |   int supports = 0;
139 |   Window *wm = (Window *) property (gdk_x11_get_default_root_xwindow (),
140 | 				    a_NET_SUPPORTING_WM_CHECK,
141 | 				    XA_WINDOW, NULL);
142 |   if (wm) {
143 |     unsigned char *win_manager = property (*wm, a_NET_WM_NAME, a_UTF8_STRING, NULL);
144 |     if (win_manager)
145 |       supports = 1;
146 |     XFree (win_manager);
147 |   }
148 |   XFree (wm);
149 |   return supports;
150 | }
151 | 
152 | char* get_window_name (Window win)
153 | {
154 |   int length = 0;
155 |   char *net_wm_visible_name = (char *) property (win, a_NET_WM_VISIBLE_NAME, a_UTF8_STRING, &length);
156 |   if (net_wm_visible_name && length)
157 |     return net_wm_visible_name;
158 |   XFree (net_wm_visible_name);
159 | 
160 |   char *net_wm_name = (char *) property (win, a_NET_WM_NAME, a_UTF8_STRING, &length);
161 |   if (net_wm_name && length)
162 |     return net_wm_name;
163 |   XFree (net_wm_name);
164 | 
165 |  char *wm_name_utf8 = (char *) property (win, a_WM_NAME, a_UTF8_STRING, &length);
166 |  if (wm_name_utf8 && length)
167 |    return wm_name_utf8;
168 |   XFree (wm_name_utf8);
169 | 
170 |   char *wm_name = (char *) property (win, a_WM_NAME, XA_STRING, &length);
171 |   if (wm_name && length)
172 |     return wm_name;
173 |   XFree (wm_name);
174 | 
175 |   return g_strdup ("<empty>");
176 | }
177 | 
178 | char* get_window_class (Window win)
179 | {
180 |   char *wm_class = (char *) property (win, a_WM_CLASS, XA_STRING, NULL);
181 |   if (wm_class)
182 |     return wm_class;
183 | 
184 |   return g_strdup ("<empty>");
185 | }
186 | 
187 | // What desktop does window belong to.
188 | int get_window_desktop (Window win)
189 | {
190 |   int32_t *desktop = property (win,
191 | 			   a_NET_WM_DESKTOP,
192 | 			   XA_CARDINAL, NULL);
193 |   int32_t result = (desktop) ? *desktop : 0;
194 |   XFree (desktop);
195 |   return result;
196 | }
197 | 
198 | // If window type is "normal" or "dialog" (or null) then show it.
199 | static gboolean show_window (Window win)
200 | {
201 |   int num = 0;
202 |   gboolean type_ok = TRUE;
203 |   Atom *type = (Atom *) property (win, a_NET_WM_WINDOW_TYPE, XA_ATOM, &num);
204 |   for (int i = 0; i < num; i++)
205 |     if (type[i] == a_NET_WM_WINDOW_TYPE_DESKTOP ||
206 | 	type[i] == a_NET_WM_WINDOW_TYPE_DOCK ||
207 | 	type[i] == a_NET_WM_WINDOW_TYPE_TOOLBAR ||
208 | 	type[i] == a_NET_WM_WINDOW_TYPE_MENU ||
209 | 	type[i] == a_NET_WM_WINDOW_TYPE_UTILITY ||
210 | 	type[i] == a_NET_WM_WINDOW_TYPE_SPLASH ||
211 | 	type[i] == a_NET_WM_WINDOW_TYPE_DROPDOWN_MENU ||
212 | 	type[i] == a_NET_WM_WINDOW_TYPE_POPUP_MENU ||
213 | 	type[i] == a_NET_WM_WINDOW_TYPE_TOOLTIP ||
214 | 	type[i] == a_NET_WM_WINDOW_TYPE_NOTIFICATION ||
215 | 	type[i] == a_NET_WM_WINDOW_TYPE_COMBO ||
216 | 	type[i] == a_NET_WM_WINDOW_TYPE_DND ||
217 | 	get_window_desktop(win) == -1) {
218 |       type_ok = FALSE;
219 |       break;
220 |     }
221 |   num = 0;
222 |   Atom *state = (Atom *) property (win, a_NET_WM_STATE, XA_ATOM, &num);
223 |   for (int i = 0; i < num; i++)
224 |     if (state[i] == a_NET_WM_STATE_SKIP_TASKBAR) {
225 |       type_ok = FALSE;
226 |       break;
227 |     }
228 | 
229 |   return type_ok;
230 | }
231 | 
232 | gboolean filter_window (Window win, Window myown, int32_t cur_desktop, gboolean only_current)
233 | {
234 |   if (show_window(win) && (win != myown)) {
235 |     if (only_current) {
236 |       return get_window_desktop(win) == cur_desktop;
237 |     } else {
238 |       return TRUE;
239 |     }
240 |   } else {
241 |     return FALSE;
242 |   }
243 | }
244 | 
245 | 
246 | // Returns a list of windows (except panels and other "non-normal" windows)
247 | Window* sorted_windows_list (Window *myown, Window *active_win, int *nitems, gboolean only_current)
248 | {
249 |   Window root_win = (Window)gdk_x11_get_default_root_xwindow ();
250 |   int32_t *cur_desktop = (int32_t *) property (root_win, a_NET_CURRENT_DESKTOP, XA_CARDINAL, NULL);
251 | 
252 |   int pre_size = 0;
253 |   Window *pre_win_list = (Window *) property (root_win, a_NET_CLIENT_LIST, XA_WINDOW, &pre_size);
254 |   if (pre_size) {
255 |     int size = 0;
256 |     // Do not show panels and all-desktop applications in list.
257 |     for (int i = 0; i < pre_size; i++)
258 |       if (filter_window(pre_win_list[i], *myown, *cur_desktop, only_current))
259 |         size++;
260 | 
261 |     Window *win_list = (Window *) malloc (size * sizeof (Window));
262 |     // That's actually kinda stupid…
263 |     int offset = 0;
264 |     for (int i = 0; i < pre_size; i++) {
265 |       if (!filter_window(pre_win_list[i], *myown, *cur_desktop, only_current)) {
266 |         offset++;
267 |         continue;
268 |       }
269 |       win_list[i-offset] = pre_win_list [i];
270 |     }
271 |     XFree (pre_win_list);
272 |     XFree (cur_desktop);
273 |     
274 |     // active window may not update it's user time.
275 |     int sort_from = 0;
276 |     if (active_win != NULL)
277 |       for (int i = 0; i < size; i++)
278 | 	if (win_list [i] == *active_win) {
279 | 	  win_list [i] = win_list [0];
280 | 	  win_list [0] = *active_win;
281 | 	  sort_from = 1;
282 | 	  break;
283 | 	}
284 | 
285 |     if (sort_from == 0) // Active window does not exist anymore.
286 |       active_win = win_list;
287 | 
288 |     unsigned int *time_list = (unsigned int *)malloc (size * sizeof (unsigned int));
289 |     for (int i = 0; i < size; i++) {
290 |       unsigned int *time = (unsigned int *) property (win_list [i], a_NET_WM_USER_TIME, XA_CARDINAL, NULL);
291 |       if (time)
292 | 	time_list [i] = *time;
293 |       else
294 | 	time_list [i] = 0;
295 |       XFree (time);
296 |     }
297 | 
298 |     // dumb sorting
299 |     for (int i = sort_from; i < size; i++)
300 |       for (int j = i+1; j < size; j++)
301 | 	if (time_list[i] < time_list [j]) {
302 | 	  unsigned int time_tmp = time_list[j];
303 | 	  time_list [j] = time_list [i];
304 | 	  time_list [i] = time_tmp;
305 | 
306 | 	  Window win_tmp = win_list [j];
307 | 	  win_list [j] = win_list [i];
308 | 	  win_list [i] = win_tmp;
309 | 	}
310 | 
311 |     free (time_list);
312 | 
313 |     *nitems = size;
314 |     return win_list;
315 |   }
316 | 
317 |   *nitems = 0;
318 |   return NULL;
319 | }
320 | 
321 | // Switch to window and it's desktop.
322 | void switch_to_window (Window win)
323 | {
324 |   Window root_window = gdk_x11_get_default_root_xwindow ();
325 |   int32_t desktop = get_window_desktop (win);
326 |   climsg (win, a_NET_ACTIVE_WINDOW, 2, CurrentTime, 0, 0, 0);
327 |   if (desktop > -1) {
328 |     climsg (root_window, a_NET_CURRENT_DESKTOP, desktop, CurrentTime, 0, 0, 0);
329 |     climsg (win, a_NET_ACTIVE_WINDOW, 2, CurrentTime, 0, 0, 0);
330 |   }
331 | }
332 | 
333 | GdkPixbuf *get_window_icon (Window win, guint req_width, guint req_height)
334 | {
335 |   GdkPixbuf *pixmap = NULL;
336 | 
337 |   /* get the _NET_WM_ICON property */
338 |   gint nitems = 0;
339 |   gulong *data = (gulong *) property (win, a_NET_WM_ICON, XA_CARDINAL, &nitems);
340 |   if (data) {
341 |     gulong *pdata = data;
342 |     gulong *pdata_end = data + nitems;
343 |     gulong *bicon = NULL;
344 |     gulong bwidth = 0;
345 |     gulong bheight = 0;
346 | 
347 |     while ((pdata+2) < pdata_end) {
348 |       gulong w = pdata [0];
349 |       gulong h = pdata [1];
350 |       gulong size = w * h;
351 |       pdata += 2;
352 | 
353 |       if (pdata + size > pdata_end)
354 | 	break;
355 | 
356 |       bicon = pdata;
357 |       bwidth = w;
358 |       bheight = h;
359 | 
360 |       if ((w >= req_width) && (h >= req_height))
361 | 	break;
362 | 
363 |       pdata += size;
364 |     }
365 | 
366 |     if (bicon != NULL) {
367 |       gulong len = bwidth * bheight;
368 |       guchar *pixdata = g_new (guchar, len * 4);
369 | 
370 |       guchar *p = pixdata;
371 |       for (int i = 0; i < len; p += 4, i++) {
372 | 	guint argb = bicon [i];
373 | 	guint rgba = (argb << 8) | (argb >> 24);
374 | 	p [0] = (rgba >> 24) & 0xff;
375 | 	p [1] = (rgba >> 16) & 0xff;
376 | 	p [2] = (rgba >>  8) & 0xff;
377 | 	p [3] = (rgba >>  0) & 0xff;
378 |       }
379 | 
380 |       GdkPixbuf *pre_pixmap = gdk_pixbuf_new_from_data
381 | 	(pixdata,
382 | 	 GDK_COLORSPACE_RGB,
383 | 	 TRUE, 8,
384 | 	 bwidth, bheight, bwidth * 4,
385 | 	 (GdkPixbufDestroyNotify) g_free,
386 | 	  NULL);
387 | 
388 |       if (bwidth > req_width || bheight > req_height) {
389 | 	pixmap = gdk_pixbuf_scale_simple (pre_pixmap,
390 | 					  req_width,
391 | 					  req_height,
392 | 					  GDK_INTERP_BILINEAR);
393 | 	g_object_unref (pre_pixmap);
394 |       } else {
395 | 	pixmap = pre_pixmap;
396 |       }
397 |     }
398 |   }
399 |   XFree (data);
400 | 
401 |   return pixmap;
402 | }
403 | 
404 | // If xwinmosaic is already opened, exit.
405 | gboolean already_opened ()
406 | {
407 |   int size = 0;
408 |   gboolean opened = FALSE;
409 |   Window *win_list = (Window *) property (gdk_x11_get_default_root_xwindow (), a_NET_CLIENT_LIST, XA_WINDOW, &size);
410 |   if (size) {
411 |     for (int i = 0; i < size; i++) {
412 |       gchar *wmclass = get_window_class (win_list [i]);
413 |       if (wmclass && show_window (win_list[i]) && !g_strcmp0 (wmclass, "xwinmosaic")) {
414 | 	opened = TRUE;
415 | 	break;
416 |       }
417 |       if (wmclass)
418 | 	g_free (wmclass);
419 |     }
420 |   }
421 |   XFree (win_list);
422 |   return opened;
423 | }
424 | 


--------------------------------------------------------------------------------
/src/x_interaction.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (c) 2012, Anton S. Lobashev
 2 |  * x_interaction.h - layer to talk with X11.
 3 |  */
 4 | 
 5 | #include <X11/Xlib.h>
 6 | #include <X11/Xatom.h>
 7 | #include <X11/extensions/Xcomposite.h>
 8 | #include <X11/extensions/Xdamage.h>
 9 | 
10 | #ifndef X_INTERACTION_H
11 | #define X_INTERACTION_H
12 | 
13 | extern Atom a_UTF8_STRING;
14 | 
15 | extern Atom a_WM_CLASS;
16 | extern Atom a_WM_NAME;
17 | extern Atom a_WM_WINDOW_ROLE;
18 | 
19 | extern Atom a_NET_SUPPORTING_WM_CHECK;
20 | extern Atom a_NET_CLIENT_LIST;
21 | extern Atom a_NET_DESKTOP_VIEWPORT;
22 | extern Atom a_NET_CURRENT_DESKTOP;
23 | extern Atom a_NET_ACTIVE_WINDOW;
24 | extern Atom a_NET_WORKAREA;
25 | 
26 | extern Atom a_NET_WM_DESKTOP;
27 | extern Atom a_NET_WM_NAME;
28 | extern Atom a_NET_WM_VISIBLE_NAME;
29 | extern Atom a_NET_WM_ICON;
30 | extern Atom a_NET_WM_USER_TIME;
31 | 
32 | extern Atom a_NET_WM_WINDOW_TYPE;
33 | 
34 | extern Atom a_NET_WM_WINDOW_TYPE_DESKTOP;
35 | extern Atom a_NET_WM_WINDOW_TYPE_DOCK;
36 | extern Atom a_NET_WM_WINDOW_TYPE_TOOLBAR;
37 | extern Atom a_NET_WM_WINDOW_TYPE_MENU;
38 | extern Atom a_NET_WM_WINDOW_TYPE_UTILITY;
39 | extern Atom a_NET_WM_WINDOW_TYPE_SPLASH;
40 | extern Atom a_NET_WM_WINDOW_TYPE_DIALOG;
41 | extern Atom a_NET_WM_WINDOW_TYPE_DROPDOWN_MENU;
42 | extern Atom a_NET_WM_WINDOW_TYPE_POPUP_MENU;
43 | extern Atom a_NET_WM_WINDOW_TYPE_TOOLTIP;
44 | extern Atom a_NET_WM_WINDOW_TYPE_NOTIFICATION;
45 | extern Atom a_NET_WM_WINDOW_TYPE_COMBO;
46 | extern Atom a_NET_WM_WINDOW_TYPE_DND;
47 | extern Atom a_NET_WM_WINDOW_TYPE_NORMAL;
48 | 
49 | extern Atom a_NET_WM_STATE;
50 | extern Atom a_NET_WM_STATE_SKIP_TASKBAR;
51 | 
52 | 
53 | void atoms_init ();
54 | void* property (Window win, Atom prop, Atom type, int *nitems);
55 | void climsg(Window win, long type, long l0, long l1, long l2, long l3, long l4);
56 | int wm_supports_ewmh ();
57 | char* get_window_name (Window win);
58 | char* get_window_class (Window win);
59 | int get_window_desktop (Window win);
60 | Window* sorted_windows_list (Window *myown, Window *active_win, int *nitems, gboolean only_current);
61 | void switch_to_window (Window win);
62 | GdkPixbuf *get_window_icon (Window win, guint req_width, guint req_height);
63 | gboolean already_opened ();
64 | 
65 | #endif /* X_INTERACTION_H */
66 | 


--------------------------------------------------------------------------------
/xwinmosaic.1:
--------------------------------------------------------------------------------
  1 | .\" Man page for xwinmosaic
  2 | .TH XWINMOSAIC 1 "June 12, 2013"
  3 | 
  4 | .SH NAME
  5 | xwinmosaic \- show X11 windows as a colourful mosaic
  6 | 
  7 | .SH SYNOPSYS
  8 | .B xwinmosaic
  9 | .RI [ "options" ] ...
 10 | 
 11 | .SH DESCRIPTION
 12 | .B xwinmosaic
 13 | is a X11 window switcher that draws windows list as colour mosaic.
 14 | It is inspired by XMonad.Actions.GridSelect, but written in C + GTK+2, uses
 15 | nice-looking colours and has some set of helpful features.
 16 | 
 17 | .P
 18 | .B xwinmosaic
 19 | can also be used as
 20 | .B dmenu
 21 | to select item from newline-separated list given from stdin and print it to stdout.
 22 | 
 23 | .P
 24 | For using
 25 | .B xwinmosaic
 26 | as a window switcher you should run it in WM that supports EWMH (Extended Window Manager Hints) specification. However, it is not necessary for read_stdin mode.
 27 | 
 28 | .SH OPTIONS
 29 | .TP
 30 | .BR \-r ", " \-\^\-read\-stdin
 31 | Read items from stdin and print selected item to stdout.
 32 | .TP
 33 | .BR \-p ", " \-\^\-permissive
 34 | Lets search entry text to be used as individual item (i.e. when no one item is mathed, text from search entry is printed to stdout).
 35 | Can be used only with
 36 | .BR \-r
 37 | option.
 38 | .TP
 39 | .BR \-t ", " \-\^\-format
 40 | Read items from stdin in next format (comma separated):
 41 | 
 42 |  <desktop_num>, <box_color>, <icon>, <label>, <opt_name>
 43 | 
 44 | Any option, except <label> can be skipped (only comma is necessary).
 45 | <icon> should be a path to png file or icon name from theme.
 46 | Any positive value of <desktop_num> is allowed.
 47 | Can be used only with
 48 | .BR \-r
 49 | option.
 50 | .TP
 51 | .TP
 52 | .BR \-V ", " \-\^\-vim\-mode
 53 | Turn on vim\-like navigation (hjkl, search on /)
 54 | .TP
 55 | .BR \-C ", " \-\^\-no\-colors
 56 | Turn off box colorizing
 57 | .TP
 58 | .BR \-I ", " \-\^\-no\-icons
 59 | Turn off showing icons
 60 | .TP
 61 | .BR \-D ", " \-\^\-no\-desktops
 62 | Turn off showing desktop number
 63 | .TP
 64 | .BR \-T ", " \-\^\-no\-titles
 65 | Turn off showing titles
 66 | .TP
 67 | .BR \-S ", " \-\^\-screenshot
 68 | Get screenshot and set it as a background (for WMs that do not support XShape)
 69 | .TP
 70 | .BR \-P ", " \-\^\-at\-pointer
 71 | Place center of mosaic at pointer position.
 72 | .TP
 73 | .BI \-W " <int>" "\fR,\fP \-\^\-box\-width=" <int>
 74 | Width of the boxes (default: 200)
 75 | .TP
 76 | .BI \-H " <int>" "\fR,\fP \-\^\-box\-height=" <int>
 77 | Height of the boxes (default: 40)
 78 | .TP
 79 | .BI \-i " <int>" "\fR,\fP \-\^\-icon\-size=" <int>
 80 | Size of window icons (default: 16)
 81 | .TP
 82 | .BI \-f " 'font [size]'" "\fR,\fP \-\^\-font=" "'font [size]'"
 83 | Which font to use for displaying widgets. (default: 'Sans 10')
 84 | .TP
 85 | .BI \-o " <int>" "\fR,\fP\-\^\-hue\-offset=" <int>
 86 | Set color hue offset (from 0 to 255)
 87 | .TP
 88 | .BI \-F " /path/to/file" "\fR,\fP \-\^\-color\-file=" /path/to/file
 89 | Pick colors from file. File format is described in USAGE section.
 90 | 
 91 | .SH USAGE
 92 | .SS Keybindings
 93 | Use arrow keys or mouse to navigate through windows. Start typing to search for required window. Use Return or mouse button 1 to confirm selection (switch to selected window or print selected item to stdout). Following hotkeys are also available:
 94 | 
 95 | .SB Default (Emacs) mode:
 96 | .TP
 97 | C\-n
 98 | Move down.
 99 | .TP
100 | C\-p
101 | Move up.
102 | .TP
103 | C\-f
104 | Move right.
105 | .TP
106 | C\-b
107 | Move left.
108 | .TP
109 | C\-h
110 | Delete character backward.
111 | .TP
112 | C\-w
113 | Delete word backward.
114 | .TP
115 | C\-m
116 | Confirm selection.
117 | 
118 | .P
119 | .SB Vim mode:
120 | .TP
121 | h
122 | Move left.
123 | .TP
124 | j
125 | Move down.
126 | .TP
127 | k
128 | Move up.
129 | .TP
130 | l
131 | Move right.
132 | .TP
133 | /
134 | Activate search.
135 | 
136 | .SS Configuration
137 | Config file is created automatically on first program run and stored in
138 | .IR ~/.config/xwinmosaic/config "."
139 | 
140 | It has the following entries:
141 | .TP
142 | .I vim_mode
143 | Should program run in vim mode.
144 | .TP
145 | .I box_width
146 | Width of the boxes.
147 | .TP
148 | .I box_height
149 | Height of the boxes.
150 | 
151 | .TP
152 | .I colorize
153 | Should program colorize boxes or not?
154 | .TP
155 | .I color_offset
156 | Set hue offset for default colorizing method (save values are beetwen 0 and 255).
157 | .TP
158 | .I show_icons
159 | Should program show icons?
160 | .TP
161 | .I show_desktop
162 | Should program show desktop number?
163 | .TP
164 | .I show_titles
165 | Should program show titles?
166 | .TP
167 | .I icon_size
168 | Size of the icons in boxes.
169 | .TP
170 | .I font
171 | Which font to use in all program widgets.
172 | .TP
173 | .I screenshot
174 | Set screenshot as a background. Useful for WM's that don't work properly with shaped windows.
175 | .TP
176 | .I screenshot_offset_x
177 | Screenshot offset by x coordinate. Can be useful if your WM does not support _NET_WM_STRUT and/or _NET_WM_STRUT_PARTIAL property.
178 | .TP
179 | .I screenshot_offset_y
180 | Screenshot offset by y coordinate. As above.
181 | .TP
182 | .I at_pointer
183 | If true, center of the mosaic is placed at the current pointer position.
184 | .TP
185 | .I color_file
186 | Path to file with colors that
187 | .B xwinmoasic
188 | should use. Colors can be set for each window class individually or be taken from
189 | .I fallback
190 | list (note each color is separated by semicolon).
191 | 
192 | .SB Color file format:
193 | .RS
194 | .TP
195 | .PD 0
196 | [colors]
197 | .TP
198 | # Use xprop to determine window class
199 | .TP
200 | WindowClass1 = #112233
201 | .TP
202 | WindowClass2 = #445566
203 | .TP
204 | # For other windows to use. You can omit that line and it will use standard colorizing scheme.
205 | .TP
206 | fallback = #778899; #AABBCC; #DDEEFF
207 | .PD
208 | .RE
209 | 
210 | .SH BUGS
211 | If you found some bug in
212 | .BR xwinmosaic ", "
213 | please report it at
214 | .IR https://github.com/soulthreads/xwinmosaic/issues "."
215 | 
216 | .SH AUTHOR
217 | xwinmosaic and this manual page is written by Anton Lobashev <soulthreads@yandex.ru>
218 | 


--------------------------------------------------------------------------------