1353 lines
36 KiB
C
1353 lines
36 KiB
C
/*
|
|
* luaa.c - Lua configuration management
|
|
*
|
|
* Copyright © 2008-2009 Julien Danjou <julien@danjou.info>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
*/
|
|
|
|
/** AwesomeWM lifecycle and low-level APIs.
|
|
*
|
|
* This module contains the functions and signal to manage the lifecycle of the
|
|
* AwesomeWM process. It allows to execute code at specific point from the early
|
|
* initialization all the way to the last events before exiting or restarting.
|
|
*
|
|
* Additionally it handles signals for spawn and keyboard related events.
|
|
*
|
|
* @author Julien Danjou <julien@danjou.info>
|
|
* @copyright 2008-2009 Julien Danjou
|
|
* @coreclassmod awesome
|
|
*/
|
|
|
|
/** Register a new xproperty.
|
|
*
|
|
* @tparam string name The name of the X11 property.
|
|
* @tparam string type One of "string", "number" or "boolean".
|
|
* @noreturn
|
|
* @staticfct register_xproperty
|
|
*/
|
|
|
|
#define _GNU_SOURCE
|
|
|
|
#include "luaa.h"
|
|
#include "globalconf.h"
|
|
#include "awesome.h"
|
|
#include "common/backtrace.h"
|
|
#include "common/version.h"
|
|
#include "config.h"
|
|
#include "event.h"
|
|
#include "objects/client.h"
|
|
#include "objects/drawable.h"
|
|
#include "objects/drawin.h"
|
|
#include "objects/selection_getter.h"
|
|
#include "objects/screen.h"
|
|
#include "objects/selection_acquire.h"
|
|
#include "objects/selection_transfer.h"
|
|
#include "objects/selection_watcher.h"
|
|
#include "objects/tag.h"
|
|
#include "property.h"
|
|
#include "selection.h"
|
|
#include "spawn.h"
|
|
#include "systray.h"
|
|
#include "xkb.h"
|
|
#include "xrdb.h"
|
|
|
|
#include <lua.h>
|
|
#include <lauxlib.h>
|
|
#include <lualib.h>
|
|
|
|
/* for strings and Unicode handling */
|
|
#include <glib.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <basedir_fs.h>
|
|
|
|
#include <xcb/xcb_atom.h>
|
|
#include <xcb/xcb_aux.h>
|
|
#include "xkb_utf32_to_keysym_compat.c"
|
|
|
|
#include <unistd.h> /* for gethostname() */
|
|
|
|
#ifdef WITH_DBUS
|
|
extern const struct luaL_Reg awesome_dbus_lib[];
|
|
#endif
|
|
extern const struct luaL_Reg awesome_keygrabber_lib[];
|
|
extern const struct luaL_Reg awesome_mousegrabber_lib[];
|
|
extern const struct luaL_Reg awesome_mouse_methods[];
|
|
extern const struct luaL_Reg awesome_mouse_meta[];
|
|
extern const struct luaL_Reg awesome_root_methods[];
|
|
extern const struct luaL_Reg awesome_root_meta[];
|
|
|
|
signal_array_t global_signals;
|
|
|
|
/** A call into the Lua code aborted with an error.
|
|
*
|
|
* This signal is used in the example configuration, @{05-awesomerc.md},
|
|
* to let a notification box pop up.
|
|
* @tparam table err Table with the error object, can be converted to a string with
|
|
* `tostring(err)`.
|
|
* @signal debug::error
|
|
*/
|
|
|
|
/** A deprecated Lua function was called.
|
|
*
|
|
* @tparam string hint String with a hint on what to use instead of the
|
|
* deprecated functionality.
|
|
* @tparam[opt=nil] string|nil see The name of the newer API
|
|
* @tparam[opt=nil] table|nil args The name of the newer API
|
|
* @signal debug::deprecation
|
|
*/
|
|
|
|
/** An invalid key was read from an object.
|
|
*
|
|
* This can happen if `foo` in an `c.foo` access does not exist.
|
|
* @param unknown1 Class?
|
|
* @param unknown2 Key?
|
|
* @signal debug::index::miss
|
|
*/
|
|
|
|
/** An invalid key was written to an object.
|
|
*
|
|
* This can happen if `foo` in an `c.foo = "bar"` assignment doesn't exist.
|
|
* @param unknown1 Class?
|
|
* @param unknown2 Key?
|
|
* @param unknown3 Value?
|
|
* @signal debug::newindex::miss
|
|
*/
|
|
|
|
/** The systray should be updated.
|
|
*
|
|
* This signal is used in `wibox.widget.systray`.
|
|
* @signal systray::update
|
|
*/
|
|
|
|
/** The wallpaper has changed.
|
|
*
|
|
* This signal is used for pseudo-transparency in `wibox.drawable` if no
|
|
* composite manager is running.
|
|
* @signal wallpaper_changed
|
|
*/
|
|
|
|
/** Keyboard map has changed.
|
|
*
|
|
* This signal is sent after the new keymap has been loaded. It is used in
|
|
* `awful.widget.keyboardlayout` to redraw the layout.
|
|
* @signal xkb::map_changed
|
|
*/
|
|
|
|
/** Keyboard group has changed.
|
|
*
|
|
* It's used in `awful.widget.keyboardlayout` to redraw the layout.
|
|
* @tparam number group Integer containing the changed group
|
|
* @signal xkb::group_changed.
|
|
*/
|
|
|
|
/** Refresh.
|
|
*
|
|
* This signal is emitted as a kind of idle signal in the event loop.
|
|
* One example usage is in `gears.timer` to executed delayed calls.
|
|
* @signal refresh
|
|
*/
|
|
|
|
/** AwesomeWM is about to enter the event loop.
|
|
*
|
|
* This means all initialization has been done.
|
|
* @signal startup
|
|
*/
|
|
|
|
/** AwesomeWM is exiting / about to restart.
|
|
*
|
|
* This signal is emitted in the `atexit` handler as well when awesome
|
|
* restarts.
|
|
* @tparam boolean reason_restart Boolean value is true if the signal was sent
|
|
* because of a restart.
|
|
* @signal exit
|
|
*/
|
|
|
|
/** The output status of a screen has changed.
|
|
*
|
|
* @tparam string output String containing which output has changed.
|
|
* @tparam string connection_state String containing the connection status of
|
|
* the output: It will be either "Connected", "Disconnected" or
|
|
* "Unknown".
|
|
* @signal screen::change
|
|
*/
|
|
|
|
/** Path to config file */
|
|
static char *conffile;
|
|
|
|
/** Check whether a composite manager is running.
|
|
* \return True if such a manager is running.
|
|
*/
|
|
static bool
|
|
composite_manager_running(void)
|
|
{
|
|
xcb_intern_atom_reply_t *atom_r;
|
|
xcb_get_selection_owner_reply_t *selection_r;
|
|
char *atom_name;
|
|
bool result;
|
|
|
|
if(!(atom_name = xcb_atom_name_by_screen("_NET_WM_CM", globalconf.default_screen)))
|
|
{
|
|
warn("error getting composite manager atom");
|
|
return false;
|
|
}
|
|
|
|
atom_r = xcb_intern_atom_reply(globalconf.connection,
|
|
xcb_intern_atom_unchecked(globalconf.connection, false,
|
|
a_strlen(atom_name), atom_name),
|
|
NULL);
|
|
p_delete(&atom_name);
|
|
if(!atom_r)
|
|
return false;
|
|
|
|
selection_r = xcb_get_selection_owner_reply(globalconf.connection,
|
|
xcb_get_selection_owner_unchecked(globalconf.connection,
|
|
atom_r->atom),
|
|
NULL);
|
|
p_delete(&atom_r);
|
|
|
|
result = selection_r != NULL && selection_r->owner != XCB_NONE;
|
|
p_delete(&selection_r);
|
|
|
|
return result;
|
|
}
|
|
|
|
/** Quit awesome.
|
|
* @tparam[opt=0] integer code The exit code to use when exiting.
|
|
* @staticfct quit
|
|
* @noreturn
|
|
*/
|
|
static int
|
|
luaA_quit(lua_State *L)
|
|
{
|
|
if (!lua_isnoneornil(L, 1))
|
|
globalconf.exit_code = luaL_checkinteger(L, 1);
|
|
if (globalconf.loop == NULL)
|
|
globalconf.loop = g_main_loop_new(NULL, FALSE);
|
|
g_main_loop_quit(globalconf.loop);
|
|
return 0;
|
|
}
|
|
|
|
/** Execute another application, probably a window manager, to replace
|
|
* awesome.
|
|
*
|
|
* @tparam string cmd The command line to execute.
|
|
* @staticfct exec
|
|
* @noreturn
|
|
*/
|
|
static int
|
|
luaA_exec(lua_State *L)
|
|
{
|
|
const char *cmd = luaL_checkstring(L, 1);
|
|
|
|
awesome_atexit(false);
|
|
|
|
a_exec(cmd);
|
|
return 0;
|
|
}
|
|
|
|
/** Restart awesome.
|
|
* @staticfct restart
|
|
* @noreturn
|
|
*/
|
|
static int
|
|
luaA_restart(lua_State *L)
|
|
{
|
|
awesome_restart();
|
|
return 0;
|
|
}
|
|
|
|
/** Send a signal to a process.
|
|
* @tparam integer pid Process identifier. 0 and negative values have special
|
|
* meaning. See `man 3 kill`.
|
|
* @tparam integer sig Signal number.
|
|
* See `awesome.unix_signal` for a list of signals.
|
|
* @treturn boolean true if the signal was successfully sent, else false
|
|
* @staticfct kill
|
|
*/
|
|
static int
|
|
luaA_kill(lua_State *L)
|
|
{
|
|
int pid = luaL_checknumber(L, 1);
|
|
int sig = luaA_checknumber_range(L, 2, 0, INT_MAX);
|
|
|
|
int result = kill(pid, sig);
|
|
lua_pushboolean(L, result == 0);
|
|
return 1;
|
|
}
|
|
|
|
/** Synchronize with the X11 server. This is needed in the test suite to avoid
|
|
* some race conditions. You should never need to use this function.
|
|
* @staticfct sync
|
|
* @noreturn
|
|
*/
|
|
static int
|
|
luaA_sync(lua_State *L)
|
|
{
|
|
xcb_aux_sync(globalconf.connection);
|
|
return 0;
|
|
}
|
|
|
|
/** Translate a GdkPixbuf to a cairo image surface..
|
|
*
|
|
* @param pixbuf The pixbuf as a light user datum.
|
|
* @param path The pixbuf origin path
|
|
* @treturn gears.surface A cairo surface as light user datum.
|
|
* @staticfct pixbuf_to_surface
|
|
*/
|
|
static int
|
|
luaA_pixbuf_to_surface(lua_State *L)
|
|
{
|
|
GdkPixbuf *pixbuf = (GdkPixbuf *) lua_touserdata(L, 1);
|
|
cairo_surface_t *surface = draw_surface_from_pixbuf(pixbuf);
|
|
|
|
/* lua has to make sure to free the ref or we have a leak */
|
|
lua_pushlightuserdata(L, surface);
|
|
return 1;
|
|
}
|
|
|
|
/** Load an image from a given path.
|
|
*
|
|
* @tparam string name The file name.
|
|
* @treturn gears.surface A cairo surface as light user datum.
|
|
* @treturn nil|string The error message, if any.
|
|
* @staticfct load_image
|
|
* @deprecated awesome.pixbuf_to_surface
|
|
*/
|
|
static int
|
|
luaA_load_image(lua_State *L)
|
|
{
|
|
luaA_deprecate(L, "awesome.pixbuf_to_surface");
|
|
GError *error = NULL;
|
|
const char *filename = luaL_checkstring(L, 1);
|
|
cairo_surface_t *surface = draw_load_image(L, filename, &error);
|
|
if (!surface) {
|
|
lua_pushnil(L);
|
|
lua_pushstring(L, error->message);
|
|
g_error_free(error);
|
|
return 2;
|
|
}
|
|
|
|
/* lua has to make sure to free the ref or we have a leak */
|
|
lua_pushlightuserdata(L, surface);
|
|
return 1;
|
|
}
|
|
|
|
/** Set the preferred size for client icons.
|
|
*
|
|
* The closest equal or bigger size is picked if present, otherwise the closest
|
|
* smaller size is picked. The default is 0 pixels, ie. the smallest icon.
|
|
*
|
|
* @tparam integer size The size of the icons in pixels.
|
|
* @staticfct set_preferred_icon_size
|
|
* @noreturn
|
|
*/
|
|
static int
|
|
luaA_set_preferred_icon_size(lua_State *L)
|
|
{
|
|
globalconf.preferred_icon_size = luaA_checkinteger_range(L, 1, 0, UINT32_MAX);
|
|
return 0;
|
|
}
|
|
|
|
/** UTF-8 aware string length computing.
|
|
* \param L The Lua VM state.
|
|
* \return The number of elements pushed on stack.
|
|
*/
|
|
static int
|
|
luaA_mbstrlen(lua_State *L)
|
|
{
|
|
const char *cmd = luaL_checkstring(L, 1);
|
|
lua_pushinteger(L, (ssize_t) mbstowcs(NULL, NONULL(cmd), 0));
|
|
return 1;
|
|
}
|
|
|
|
/** Enhanced type() function which recognize awesome objects.
|
|
* \param L The Lua VM state.
|
|
* \return The number of arguments pushed on the stack.
|
|
*/
|
|
static int
|
|
luaAe_type(lua_State *L)
|
|
{
|
|
luaL_checkany(L, 1);
|
|
lua_pushstring(L, luaA_typename(L, 1));
|
|
return 1;
|
|
}
|
|
|
|
/** Replace various standards Lua functions with our own.
|
|
* \param L The Lua VM state.
|
|
*/
|
|
static void
|
|
luaA_fixups(lua_State *L)
|
|
{
|
|
/* export string.wlen */
|
|
lua_getglobal(L, "string");
|
|
lua_pushcfunction(L, luaA_mbstrlen);
|
|
lua_setfield(L, -2, "wlen");
|
|
lua_pop(L, 1);
|
|
/* replace type */
|
|
lua_pushcfunction(L, luaAe_type);
|
|
lua_setglobal(L, "type");
|
|
}
|
|
|
|
static const char *
|
|
get_modifier_name(int map_index)
|
|
{
|
|
switch (map_index) {
|
|
case XCB_MAP_INDEX_SHIFT: return "Shift";
|
|
case XCB_MAP_INDEX_LOCK: return "Lock";
|
|
case XCB_MAP_INDEX_CONTROL: return "Control";
|
|
case XCB_MAP_INDEX_1: return "Mod1"; /* Alt */
|
|
case XCB_MAP_INDEX_2: return "Mod2";
|
|
case XCB_MAP_INDEX_3: return "Mod3";
|
|
case XCB_MAP_INDEX_4: return "Mod4";
|
|
case XCB_MAP_INDEX_5: return "Mod5";
|
|
|
|
}
|
|
|
|
return 0; /* \0 */
|
|
}
|
|
|
|
/* Helper function for luaA_get_key_name() below.
|
|
* Will return the UTF-32 codepoint IF AND ONLY IF the input is exactly one
|
|
* valid UTF-8 character. Otherwise, it will return zero.
|
|
*/
|
|
static uint32_t
|
|
one_utf8_to_utf32(const char* input, const size_t length) {
|
|
gunichar character = g_utf8_get_char_validated(input, length);
|
|
// Return 0 if there is more than one UTF-8 character:
|
|
if (g_unichar_to_utf8(character, NULL) != (gint)length)
|
|
return 0;
|
|
// Return 0 if the character is invalid.
|
|
if (character == (gunichar)-1 || character == (gunichar)-2)
|
|
return 0;
|
|
return character;
|
|
}
|
|
|
|
/* Get X11 keysym and a one-character representation from an Awesome keycode.
|
|
*
|
|
* A "one-character representation" is a single UTF-8 representing the typical
|
|
* output from that keysym in a text editor (e.g. " " for space, "ñ" for
|
|
* n_tilde, "Ā" for A_macron). It usually matches the main engraving of the key
|
|
* for level-0 symbols (but lowercase).
|
|
*
|
|
* Keycodes may be given in a string in any valid format for `awful.key`:
|
|
* "#" + keycode, the symkey name and the UTF-8 representation will all work.
|
|
*
|
|
* If no suitable keysym is found, or a malformed keycode is given as an
|
|
* argument, this function will return (nil, nil)
|
|
*
|
|
* @treturn[1] string keysym The keysym name
|
|
* @treturn[1] nil keysym If no valid keysym is found
|
|
* @treturn[2] string printsymbol The xkb_keysym_to_utf8 result
|
|
* @treturn[2] nil printsymbol If the keysym has no printable representation.
|
|
* @staticfct awful.keyboard.get_key_name
|
|
*/
|
|
|
|
static int
|
|
luaA_get_key_name(lua_State *L)
|
|
{
|
|
// check if argument is valid
|
|
if (lua_gettop(L) > 1 || lua_type(L, 1) != LUA_TSTRING)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
const char* input = luaL_checkstring(L, 1);
|
|
const xkb_keysym_t *keysyms;
|
|
xkb_keysym_t keysym = XKB_KEY_NoSymbol;
|
|
const size_t length = strlen(input);
|
|
uint32_t ucs;
|
|
|
|
/* Checking for the three possible syntaxes awful.key uses:
|
|
* 1: #keycode (#8 to #255, any other is invalid)
|
|
* 2: the symbol itself (the result of xkb_keysym_to_utf8, e.g. @ for at).
|
|
* 3: the keysym
|
|
*/
|
|
if (input[0] == '#' && input[1] != '\0' && length < 5) // syntax #1
|
|
{
|
|
int keycode_from_hash = atoi(input+1);
|
|
// We discard keycodes with invalid values:
|
|
const xcb_setup_t *setup = xcb_get_setup(globalconf.connection);
|
|
if (keycode_from_hash < setup->min_keycode ||
|
|
keycode_from_hash > setup->max_keycode)
|
|
return 0;
|
|
xkb_keycode_t keycode = (xkb_keycode_t) keycode_from_hash;
|
|
struct xkb_keymap *keymap = xkb_state_get_keymap(globalconf.xkb_state);
|
|
xkb_keymap_key_get_syms_by_level(keymap, keycode, 0, 0, &keysyms);
|
|
keysym = keysyms[0];
|
|
}
|
|
else if ((ucs = one_utf8_to_utf32(input, length)) > 0) //syntax #2
|
|
keysym = xkb_utf32_to_keysym_compat(ucs);
|
|
else //syntax #3
|
|
keysym = xkb_keysym_from_name(input, XKB_KEYSYM_NO_FLAGS);
|
|
|
|
if (keysym == XKB_KEY_NoSymbol)
|
|
return 0;
|
|
else
|
|
{
|
|
char *name = key_get_keysym_name(keysym);
|
|
lua_pushstring(L, name);
|
|
char utfname[8];
|
|
if (xkb_keysym_to_utf8(keysym, utfname, 8) > 0)
|
|
lua_pushstring(L, utfname);
|
|
else
|
|
return 1; // this will make the second returned value a nil
|
|
}
|
|
return 2;
|
|
}
|
|
|
|
/* Undocumented */
|
|
/*
|
|
* The table of keybindings modifiers.
|
|
*
|
|
* Each modifier has zero to many entries depending on the keyboard layout.
|
|
* For example, `Shift` usually both has a left and right variant. Each
|
|
* modifier entry has a `keysym` and `keycode` entry. For the US PC 105
|
|
* keyboard, it looks like:
|
|
*
|
|
* awesome.modifiers = {
|
|
* Shift = {
|
|
* {keycode = 50 , keysym = 'Shift_L' },
|
|
* {keycode = 62 , keysym = 'Shift_R' },
|
|
* },
|
|
* Lock = {},
|
|
* Control = {
|
|
* {keycode = 37 , keysym = 'Control_L' },
|
|
* {keycode = 105, keysym = 'Control_R' },
|
|
* },
|
|
* Mod1 = {
|
|
* {keycode = 64 , keysym = 'Alt_L' },
|
|
* {keycode = 108, keysym = 'Alt_R' },
|
|
* },
|
|
* Mod2 = {
|
|
* {keycode = 77 , keysym = 'Num_Lock' },
|
|
* },
|
|
* Mod3 = {},
|
|
* Mod4 = {
|
|
* {keycode = 133, keysym = 'Super_L' },
|
|
* {keycode = 134, keysym = 'Super_R' },
|
|
* },
|
|
* Mod5 = {
|
|
* {keycode = 203, keysym = 'Mode_switch'},
|
|
* },
|
|
* };
|
|
*
|
|
* @tfield table modifiers
|
|
* @tparam table modifiers.Shift The Shift modifiers.
|
|
* @tparam table modifiers.Lock The Lock modifiers.
|
|
* @tparam table modifiers.Control The Control modifiers.
|
|
* @tparam table modifiers.Mod1 The Mod1 (Alt) modifiers.
|
|
* @tparam table modifiers.Mod2 The Mod2 modifiers.
|
|
* @tparam table modifiers.Mod3 The Mod3 modifiers.
|
|
* @tparam table modifiers.Mod4 The Mod4 modifiers.
|
|
* @tparam table modifiers.Mod5 The Mod5 modifiers.
|
|
*/
|
|
|
|
/*
|
|
* Modifiers can change over time, given they are currently not tracked, just
|
|
* query them each time. Use with moderation.
|
|
*/
|
|
static int luaA_get_modifiers(lua_State *L)
|
|
{
|
|
xcb_get_modifier_mapping_reply_t *mods = xcb_get_modifier_mapping_reply(globalconf.connection,
|
|
xcb_get_modifier_mapping(globalconf.connection), NULL);
|
|
if (!mods)
|
|
return 0;
|
|
|
|
xcb_keycode_t *mappings = xcb_get_modifier_mapping_keycodes(mods);
|
|
struct xkb_keymap *keymap = xkb_state_get_keymap(globalconf.xkb_state);
|
|
|
|
lua_newtable(L);
|
|
|
|
/* This get the MAPPED modifiers, not all of them are */
|
|
for (int i = XCB_MAP_INDEX_SHIFT; i <= XCB_MAP_INDEX_5; i++) {
|
|
lua_pushstring(L, get_modifier_name(i));
|
|
lua_newtable(L);
|
|
|
|
for (int j = 0; j < mods->keycodes_per_modifier; j++) {
|
|
const xkb_keysym_t *keysyms;
|
|
const xcb_keycode_t key_code = mappings[i * mods->keycodes_per_modifier + j];
|
|
xkb_keymap_key_get_syms_by_level(keymap, key_code, 0, 0, &keysyms);
|
|
if (keysyms != NULL) {
|
|
/* The +1 because j starts at zero and Lua at 1 */
|
|
lua_pushinteger(L, j+1);
|
|
|
|
lua_newtable(L);
|
|
|
|
lua_pushstring(L, "keycode");
|
|
lua_pushinteger(L, key_code);
|
|
lua_settable(L, -3);
|
|
|
|
/* Technically it is possible to get multiple keysyms here,
|
|
* but... we just use the first one.
|
|
*/
|
|
lua_pushstring(L, "keysym");
|
|
char *string = key_get_keysym_name(keysyms[0]);
|
|
lua_pushstring(L, string);
|
|
p_delete(&string);
|
|
lua_settable(L, -3);
|
|
|
|
lua_settable(L, -3);
|
|
}
|
|
}
|
|
lua_settable(L, -3);
|
|
}
|
|
|
|
free(mods);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Undocumented */
|
|
/*
|
|
* A table with the currently active modifier names.
|
|
*
|
|
* @tfield table _active_modifiers
|
|
*/
|
|
|
|
static int luaA_get_active_modifiers(lua_State *L)
|
|
{
|
|
int count = 1;
|
|
lua_newtable(L);
|
|
|
|
for (int i = XCB_MAP_INDEX_SHIFT; i <= XCB_MAP_INDEX_5; i++) {
|
|
const int active = xkb_state_mod_index_is_active (globalconf.xkb_state, i,
|
|
XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_EFFECTIVE
|
|
);
|
|
|
|
if (active) {
|
|
lua_pushstring(L, get_modifier_name(i));
|
|
lua_rawseti(L,-2, count++);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* The AwesomeWM version.
|
|
* @tfield string version
|
|
*/
|
|
|
|
/**
|
|
* The AwesomeWM release name.
|
|
* @tfield string release
|
|
*/
|
|
|
|
/**
|
|
* The AwesomeWM API level.
|
|
*
|
|
* By default, this matches the major version (first component of the version).
|
|
*
|
|
* API levels are used to allow newer version of AwesomeWM to alter the behavior
|
|
* and subset deprecated APIs. Using an older API level than the current major
|
|
* version allows to use legacy `rc.lua` with little porting. However, they won't
|
|
* be able to use all the new features. Attempting to use a newer feature along
|
|
* with an older API level is not and will not be supported, even if it almost
|
|
* works. Keeping up to date with the newer API levels is highly recommended.
|
|
*
|
|
* Going the other direction, setting an higher API level allows to take
|
|
* advantage of experimental feature. It will also be much harsher when it comes
|
|
* to deprecation. Setting the API level value beyond `current+3` will treat
|
|
* using APIs currently pending deprecation as fatal errors. All new code
|
|
* submitted to the upstream AwesomeWM codebase is forbidden to use deprecated
|
|
* APIs. Testing your patches with mode and the default config is recommended
|
|
* before submitting a patch.
|
|
*
|
|
* You can use the `-l` command line option or `api-level` modeline key to set
|
|
* the API level for your `rc.lua`. This setting is global and read only,
|
|
* individual modules cannot set their own API level.
|
|
*
|
|
* @tfield string api_level
|
|
*/
|
|
|
|
/**
|
|
* The configuration file which has been loaded.
|
|
* @tfield string conffile
|
|
*/
|
|
|
|
/**
|
|
* True if we are still in startup, false otherwise.
|
|
* @tfield boolean startup
|
|
*/
|
|
|
|
/**
|
|
* Error message for errors that occurred during
|
|
* startup.
|
|
* @tfield string startup_errors
|
|
*/
|
|
|
|
/**
|
|
* True if a composite manager is running.
|
|
* @tfield boolean composite_manager_running
|
|
*/
|
|
|
|
/**
|
|
* Table mapping between signal numbers and signal identifiers.
|
|
* @tfield table unix_signal
|
|
*/
|
|
|
|
/**
|
|
* The hostname of the computer on which we are running.
|
|
* @tfield string hostname
|
|
*/
|
|
|
|
/**
|
|
* The path where themes were installed to.
|
|
* @tfield string themes_path
|
|
*/
|
|
|
|
/**
|
|
* The path where icons were installed to.
|
|
* @tfield string icon_path
|
|
*/
|
|
|
|
static int
|
|
luaA_awesome_index(lua_State *L)
|
|
{
|
|
if(luaA_usemetatable(L, 1, 2))
|
|
return 1;
|
|
|
|
const char *buf = luaL_checkstring(L, 2);
|
|
|
|
if(A_STREQ(buf, "conffile"))
|
|
{
|
|
lua_pushstring(L, conffile);
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "version"))
|
|
{
|
|
lua_pushstring(L, awesome_version_string());
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "release"))
|
|
{
|
|
lua_pushstring(L, awesome_release_string());
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "api_level"))
|
|
{
|
|
lua_pushinteger(L, globalconf.api_level);
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "startup"))
|
|
{
|
|
lua_pushboolean(L, globalconf.loop == NULL);
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "_modifiers"))
|
|
{
|
|
luaA_get_modifiers(L);
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "_active_modifiers"))
|
|
{
|
|
luaA_get_active_modifiers(L);
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "startup_errors"))
|
|
{
|
|
if (globalconf.startup_errors.len == 0)
|
|
return 0;
|
|
lua_pushstring(L, globalconf.startup_errors.s);
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "composite_manager_running"))
|
|
{
|
|
lua_pushboolean(L, composite_manager_running());
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "hostname"))
|
|
{
|
|
/* No good way to handle failures... */
|
|
char hostname[256] = "";
|
|
gethostname(&hostname[0], countof(hostname));
|
|
hostname[countof(hostname) - 1] = '\0';
|
|
|
|
lua_pushstring(L, hostname);
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "themes_path"))
|
|
{
|
|
lua_pushliteral(L, AWESOME_THEMES_PATH);
|
|
return 1;
|
|
}
|
|
|
|
if(A_STREQ(buf, "icon_path"))
|
|
{
|
|
lua_pushliteral(L, AWESOME_ICON_PATH);
|
|
return 1;
|
|
}
|
|
|
|
return luaA_default_index(L);
|
|
}
|
|
|
|
/** Add a global signal.
|
|
*
|
|
* @tparam string name A string with the event name.
|
|
* @tparam function func The function to call.
|
|
* @staticfct connect_signal
|
|
* @noreturn
|
|
*/
|
|
static int
|
|
luaA_awesome_connect_signal(lua_State *L)
|
|
{
|
|
const char *name = luaL_checkstring(L, 1);
|
|
luaA_checkfunction(L, 2);
|
|
signal_connect(&global_signals, name, luaA_object_ref(L, 2));
|
|
return 0;
|
|
}
|
|
|
|
/** Remove a global signal.
|
|
*
|
|
* @tparam string name A string with the event name.
|
|
* @tparam function func The function to call.
|
|
* @staticfct disconnect_signal
|
|
* @noreturn
|
|
*/
|
|
static int
|
|
luaA_awesome_disconnect_signal(lua_State *L)
|
|
{
|
|
const char *name = luaL_checkstring(L, 1);
|
|
luaA_checkfunction(L, 2);
|
|
const void *func = lua_topointer(L, 2);
|
|
if (signal_disconnect(&global_signals, name, func))
|
|
luaA_object_unref(L, (void *) func);
|
|
return 0;
|
|
}
|
|
|
|
/** Emit a global signal.
|
|
*
|
|
* @tparam function name A string with the event name.
|
|
* @param ... The signal arguments.
|
|
* @staticfct emit_signal
|
|
* @noreturn
|
|
*/
|
|
static int
|
|
luaA_awesome_emit_signal(lua_State *L)
|
|
{
|
|
signal_object_emit(L, &global_signals, luaL_checkstring(L, 1), lua_gettop(L) - 1);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
luaA_panic(lua_State *L)
|
|
{
|
|
warn("unprotected error in call to Lua API (%s)",
|
|
lua_tostring(L, -1));
|
|
buffer_t buf;
|
|
backtrace_get(&buf);
|
|
warn("dumping backtrace\n%s", buf.s);
|
|
warn("restarting awesome");
|
|
awesome_restart();
|
|
return 0;
|
|
}
|
|
|
|
#if LUA_VERSION_NUM >= 502
|
|
static const char *
|
|
luaA_tolstring(lua_State *L, int idx, size_t *len)
|
|
{
|
|
return luaL_tolstring(L, idx, len);
|
|
}
|
|
#else
|
|
static const char *
|
|
luaA_tolstring(lua_State *L, int idx, size_t *len)
|
|
{
|
|
/* Try using the metatable. If that fails, push the value itself onto
|
|
* the stack.
|
|
*/
|
|
if (!luaL_callmeta(L, idx, "__tostring"))
|
|
lua_pushvalue(L, idx);
|
|
|
|
switch (lua_type(L, -1)) {
|
|
case LUA_TSTRING:
|
|
lua_pushvalue(L, -1);
|
|
break;
|
|
case LUA_TBOOLEAN:
|
|
if (lua_toboolean(L, -1))
|
|
lua_pushliteral(L, "true");
|
|
else
|
|
lua_pushliteral(L, "false");
|
|
break;
|
|
case LUA_TNUMBER:
|
|
lua_pushfstring(L, "%f", lua_tonumber(L, -1));
|
|
break;
|
|
case LUA_TNIL:
|
|
lua_pushstring(L, "nil");
|
|
break;
|
|
default:
|
|
lua_pushfstring(L, "%s: %p",
|
|
lua_typename(L, lua_type(L, -1)),
|
|
lua_topointer(L, -1));
|
|
break;
|
|
}
|
|
lua_remove(L, -2);
|
|
return lua_tolstring(L, -1, len);
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
luaA_dofunction_on_error(lua_State *L)
|
|
{
|
|
/* Convert error to string, to prevent a follow-up error with lua_concat. */
|
|
luaA_tolstring(L, -1, NULL);
|
|
|
|
/* duplicate string error */
|
|
lua_pushvalue(L, -1);
|
|
/* emit error signal */
|
|
signal_object_emit(L, &global_signals, "debug::error", 1);
|
|
|
|
if(!luaL_dostring(L, "return debug.traceback(\"error while running function!\", 3)"))
|
|
{
|
|
/* Move traceback before error */
|
|
lua_insert(L, -2);
|
|
/* Insert sentence */
|
|
lua_pushliteral(L, "\nerror: ");
|
|
/* Move it before error */
|
|
lua_insert(L, -2);
|
|
lua_concat(L, 3);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
setup_awesome_signals(lua_State *L)
|
|
{
|
|
lua_getglobal(L, "awesome");
|
|
lua_pushstring(L, "unix_signal");
|
|
lua_newtable(L);
|
|
|
|
#define SETUP_SIGNAL(sig) \
|
|
do { \
|
|
/* Set awesome.unix_signal["SIGSTOP"] = 42 */ \
|
|
lua_pushinteger(L, sig); \
|
|
lua_setfield(L, -2, #sig); \
|
|
/* Set awesome.unix_signal[42] = "SIGSTOP" */ \
|
|
lua_pushinteger(L, sig); \
|
|
lua_pushstring(L, #sig); \
|
|
lua_settable(L, -3); \
|
|
} while (0)
|
|
|
|
/* Non-standard signals. These are first so that e.g. (on my system)
|
|
* signals[29] is SIGPOLL and not SIGIO (the value gets overwritten).
|
|
*/
|
|
#ifdef SIGIOT
|
|
SETUP_SIGNAL(SIGIOT);
|
|
#endif
|
|
#ifdef SIGEMT
|
|
SETUP_SIGNAL(SIGEMT);
|
|
#endif
|
|
#ifdef SIGSTKFLT
|
|
SETUP_SIGNAL(SIGSTKFLT);
|
|
#endif
|
|
#ifdef SIGIO
|
|
SETUP_SIGNAL(SIGIO);
|
|
#endif
|
|
#ifdef SIGCLD
|
|
SETUP_SIGNAL(SIGCLD);
|
|
#endif
|
|
#ifdef SIGPWR
|
|
SETUP_SIGNAL(SIGPWR);
|
|
#endif
|
|
#ifdef SIGINFO
|
|
SETUP_SIGNAL(SIGINFO);
|
|
#endif
|
|
#ifdef SIGLOST
|
|
SETUP_SIGNAL(SIGLOST);
|
|
#endif
|
|
#ifdef SIGWINCH
|
|
SETUP_SIGNAL(SIGWINCH);
|
|
#endif
|
|
#ifdef SIGUNUSED
|
|
SETUP_SIGNAL(SIGUNUSED);
|
|
#endif
|
|
|
|
/* POSIX.1-1990, according to man 7 signal */
|
|
SETUP_SIGNAL(SIGHUP);
|
|
SETUP_SIGNAL(SIGINT);
|
|
SETUP_SIGNAL(SIGQUIT);
|
|
SETUP_SIGNAL(SIGILL);
|
|
SETUP_SIGNAL(SIGABRT);
|
|
SETUP_SIGNAL(SIGFPE);
|
|
SETUP_SIGNAL(SIGKILL);
|
|
SETUP_SIGNAL(SIGSEGV);
|
|
SETUP_SIGNAL(SIGPIPE);
|
|
SETUP_SIGNAL(SIGALRM);
|
|
SETUP_SIGNAL(SIGTERM);
|
|
SETUP_SIGNAL(SIGUSR1);
|
|
SETUP_SIGNAL(SIGUSR2);
|
|
SETUP_SIGNAL(SIGCHLD);
|
|
SETUP_SIGNAL(SIGCONT);
|
|
SETUP_SIGNAL(SIGSTOP);
|
|
SETUP_SIGNAL(SIGTSTP);
|
|
SETUP_SIGNAL(SIGTTIN);
|
|
SETUP_SIGNAL(SIGTTOU);
|
|
|
|
/* POSIX.1-2001, according to man 7 signal */
|
|
SETUP_SIGNAL(SIGBUS);
|
|
/* Some Operating Systems doesn't have SIGPOLL (e.g. FreeBSD) */
|
|
#ifdef SIGPOLL
|
|
SETUP_SIGNAL(SIGPOLL);
|
|
#endif
|
|
SETUP_SIGNAL(SIGPROF);
|
|
SETUP_SIGNAL(SIGSYS);
|
|
SETUP_SIGNAL(SIGTRAP);
|
|
SETUP_SIGNAL(SIGURG);
|
|
SETUP_SIGNAL(SIGVTALRM);
|
|
SETUP_SIGNAL(SIGXCPU);
|
|
SETUP_SIGNAL(SIGXFSZ);
|
|
|
|
#undef SETUP_SIGNAL
|
|
|
|
/* Set awesome.signal to the table we just created, key was already pushed */
|
|
lua_rawset(L, -3);
|
|
|
|
/* Pop "awesome" */
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
/* Add things to the string on top of the stack */
|
|
static void
|
|
add_to_search_path(lua_State *L, string_array_t *searchpath, bool for_lua)
|
|
{
|
|
if (LUA_TSTRING != lua_type(L, -1))
|
|
{
|
|
warn("package.path is not a string");
|
|
return;
|
|
}
|
|
|
|
foreach(entry, *searchpath)
|
|
{
|
|
int components;
|
|
size_t len = a_strlen(*entry);
|
|
lua_pushliteral(L, ";");
|
|
lua_pushlstring(L, *entry, len);
|
|
if (for_lua)
|
|
lua_pushliteral(L, "/?.lua");
|
|
else
|
|
lua_pushliteral(L, "/?.so");
|
|
lua_concat(L, 3);
|
|
|
|
if (for_lua)
|
|
{
|
|
lua_pushliteral(L, ";");
|
|
lua_pushlstring(L, *entry, len);
|
|
lua_pushliteral(L, "/?/init.lua");
|
|
lua_concat(L, 3);
|
|
|
|
components = 2;
|
|
} else {
|
|
components = 1;
|
|
}
|
|
lua_concat(L, components + 1); /* concatenate with string on top of the stack */
|
|
}
|
|
|
|
/* add Lua lib path (/usr/share/awesome/lib by default) */
|
|
if (for_lua)
|
|
{
|
|
lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?.lua");
|
|
lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?/init.lua");
|
|
lua_concat(L, 3); /* concatenate with thing on top of the stack when we were called */
|
|
} else {
|
|
lua_pushliteral(L, ";" AWESOME_LUA_LIB_PATH "/?.so");
|
|
lua_concat(L, 2); /* concatenate with thing on top of the stack when we were called */
|
|
}
|
|
}
|
|
|
|
/** Initialize the Lua VM
|
|
* \param xdg An xdg handle to use to get XDG basedir.
|
|
*/
|
|
void
|
|
luaA_init(xdgHandle* xdg, string_array_t *searchpath)
|
|
{
|
|
lua_State *L;
|
|
static const struct luaL_Reg awesome_lib[] =
|
|
{
|
|
{ "quit", luaA_quit },
|
|
{ "exec", luaA_exec },
|
|
{ "spawn", luaA_spawn },
|
|
{ "restart", luaA_restart },
|
|
{ "connect_signal", luaA_awesome_connect_signal },
|
|
{ "disconnect_signal", luaA_awesome_disconnect_signal },
|
|
{ "emit_signal", luaA_awesome_emit_signal },
|
|
{ "systray", luaA_systray },
|
|
{ "load_image", luaA_load_image },
|
|
{ "pixbuf_to_surface", luaA_pixbuf_to_surface },
|
|
{ "set_preferred_icon_size", luaA_set_preferred_icon_size },
|
|
{ "register_xproperty", luaA_register_xproperty },
|
|
{ "set_xproperty", luaA_set_xproperty },
|
|
{ "get_xproperty", luaA_get_xproperty },
|
|
{ "__index", luaA_awesome_index },
|
|
{ "__newindex", luaA_default_newindex },
|
|
{ "xkb_set_layout_group", luaA_xkb_set_layout_group},
|
|
{ "xkb_get_layout_group", luaA_xkb_get_layout_group},
|
|
{ "xkb_get_group_names", luaA_xkb_get_group_names},
|
|
{ "xrdb_get_value", luaA_xrdb_get_value},
|
|
{ "kill", luaA_kill},
|
|
{ "sync", luaA_sync},
|
|
{ "_get_key_name", luaA_get_key_name},
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
L = globalconf.L.real_L_dont_use_directly = luaL_newstate();
|
|
|
|
/* Set panic function */
|
|
lua_atpanic(L, luaA_panic);
|
|
|
|
/* Set error handling function */
|
|
lualib_dofunction_on_error = luaA_dofunction_on_error;
|
|
|
|
luaL_openlibs(L);
|
|
|
|
luaA_fixups(L);
|
|
|
|
luaA_object_setup(L);
|
|
|
|
/* Export awesome lib */
|
|
luaA_openlib(L, "awesome", awesome_lib, awesome_lib);
|
|
setup_awesome_signals(L);
|
|
|
|
/* Export root lib */
|
|
luaA_openlib(L, "root", awesome_root_methods, awesome_root_meta);
|
|
|
|
#ifdef WITH_DBUS
|
|
/* Export D-Bus lib */
|
|
luaA_registerlib(L, "dbus", awesome_dbus_lib);
|
|
lua_pop(L, 1); /* luaA_registerlib() leaves the table on stack */
|
|
#endif
|
|
|
|
/* Export keygrabber lib */
|
|
luaA_registerlib(L, "keygrabber", awesome_keygrabber_lib);
|
|
lua_pop(L, 1); /* luaA_registerlib() leaves the table on stack */
|
|
|
|
/* Export mousegrabber lib */
|
|
luaA_registerlib(L, "mousegrabber", awesome_mousegrabber_lib);
|
|
lua_pop(L, 1); /* luaA_registerlib() leaves the table on stack */
|
|
|
|
/* Export mouse */
|
|
luaA_openlib(L, "mouse", awesome_mouse_methods, awesome_mouse_meta);
|
|
|
|
/* Export screen */
|
|
screen_class_setup(L);
|
|
|
|
/* Export button */
|
|
button_class_setup(L);
|
|
|
|
/* Export tag */
|
|
tag_class_setup(L);
|
|
|
|
/* Export window */
|
|
window_class_setup(L);
|
|
|
|
/* Export drawable */
|
|
drawable_class_setup(L);
|
|
|
|
/* Export drawin */
|
|
drawin_class_setup(L);
|
|
|
|
/* Export client */
|
|
client_class_setup(L);
|
|
|
|
/* Export selection getter */
|
|
selection_getter_class_setup(L);
|
|
|
|
/* Export keys */
|
|
key_class_setup(L);
|
|
|
|
/* Export selection acquire */
|
|
selection_acquire_class_setup(L);
|
|
|
|
/* Export selection transfer */
|
|
selection_transfer_class_setup(L);
|
|
|
|
/* Export selection watcher */
|
|
selection_watcher_class_setup(L);
|
|
|
|
/* Setup the selection interface */
|
|
selection_setup(L);
|
|
|
|
/* add Lua search paths */
|
|
lua_getglobal(L, "package");
|
|
if (LUA_TTABLE != lua_type(L, 1))
|
|
{
|
|
warn("package is not a table");
|
|
return;
|
|
}
|
|
lua_getfield(L, 1, "path");
|
|
add_to_search_path(L, searchpath, true);
|
|
lua_setfield(L, 1, "path"); /* package.path = "concatenated string" */
|
|
|
|
lua_getfield(L, 1, "cpath");
|
|
add_to_search_path(L, searchpath, false);
|
|
lua_setfield(L, 1, "cpath"); /* package.cpath = "concatenated string" */
|
|
|
|
lua_pop(L, 1); /* pop "package" */
|
|
}
|
|
|
|
static void
|
|
luaA_startup_error(const char *err)
|
|
{
|
|
if (globalconf.startup_errors.len > 0)
|
|
buffer_addsl(&globalconf.startup_errors, "\n\n");
|
|
buffer_adds(&globalconf.startup_errors, err);
|
|
}
|
|
|
|
static bool
|
|
luaA_loadrc(const char *confpath)
|
|
{
|
|
lua_State *L = globalconf_get_lua_State();
|
|
if(luaL_loadfile(L, confpath))
|
|
{
|
|
const char *err = lua_tostring(L, -1);
|
|
luaA_startup_error(err);
|
|
fprintf(stderr, "%s\n", err);
|
|
lua_pop(L, 1);
|
|
return false;
|
|
}
|
|
|
|
/* Set the conffile right now so it can be used inside the
|
|
* configuration file. */
|
|
conffile = a_strdup(confpath);
|
|
/* Move error handling function before function */
|
|
lua_pushcfunction(L, luaA_dofunction_on_error);
|
|
lua_insert(L, -2);
|
|
if(!lua_pcall(L, 0, 0, -2))
|
|
{
|
|
/* Pop luaA_dofunction_on_error */
|
|
lua_pop(L, 1);
|
|
return true;
|
|
}
|
|
|
|
const char *err = lua_tostring(L, -1);
|
|
luaA_startup_error(err);
|
|
fprintf(stderr, "%s\n", err);
|
|
/* An error happened, so reset this. */
|
|
conffile = NULL;
|
|
/* Pop luaA_dofunction_on_error() and the error message */
|
|
lua_pop(L, 2);
|
|
|
|
return false;
|
|
}
|
|
|
|
/** Load a configuration file.
|
|
* \param xdg An xdg handle to use to get XDG basedir.
|
|
* \param confpatharg The configuration file to load.
|
|
* \param run Run the configuration file.
|
|
*/
|
|
bool
|
|
luaA_parserc(xdgHandle* xdg, const char *confpatharg)
|
|
{
|
|
const char *confpath = luaA_find_config(xdg, confpatharg, luaA_loadrc);
|
|
bool ret = confpath != NULL;
|
|
p_delete(&confpath);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/** Find a config file for which the given callback returns true.
|
|
* \param xdg An xdg handle to use to get XDG basedir.
|
|
* \param confpatharg The configuration file to load.
|
|
* \param callback The callback to call.
|
|
*/
|
|
const char *
|
|
luaA_find_config(xdgHandle* xdg, const char *confpatharg, luaA_config_callback *callback)
|
|
{
|
|
char *confpath = NULL;
|
|
|
|
if(confpatharg && callback(confpatharg))
|
|
{
|
|
return a_strdup(confpatharg);
|
|
}
|
|
|
|
confpath = xdgConfigFind("awesome/rc.lua", xdg);
|
|
|
|
char *tmp = confpath;
|
|
|
|
/* confpath is "string1\0string2\0string3\0\0" */
|
|
while(*tmp)
|
|
{
|
|
if(callback(tmp))
|
|
{
|
|
const char *ret = a_strdup(tmp);
|
|
p_delete(&confpath);
|
|
return ret;
|
|
}
|
|
tmp += a_strlen(tmp) + 1;
|
|
}
|
|
p_delete(&confpath);
|
|
|
|
if(callback(AWESOME_DEFAULT_CONF))
|
|
{
|
|
return a_strdup(AWESOME_DEFAULT_CONF);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
luaA_class_index_miss_property(lua_State *L, lua_object_t *obj)
|
|
{
|
|
signal_object_emit(L, &global_signals, "debug::index::miss", 2);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
luaA_class_newindex_miss_property(lua_State *L, lua_object_t *obj)
|
|
{
|
|
signal_object_emit(L, &global_signals, "debug::newindex::miss", 3);
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
luaA_emit_startup()
|
|
{
|
|
lua_State *L = globalconf_get_lua_State();
|
|
signal_object_emit(L, &global_signals, "startup", 0);
|
|
}
|
|
|
|
void
|
|
luaA_emit_refresh()
|
|
{
|
|
lua_State *L = globalconf_get_lua_State();
|
|
signal_object_emit(L, &global_signals, "refresh", 0);
|
|
}
|
|
|
|
int
|
|
luaA_default_index(lua_State *L)
|
|
{
|
|
return luaA_class_index_miss_property(L, NULL);
|
|
}
|
|
|
|
int
|
|
luaA_default_newindex(lua_State *L)
|
|
{
|
|
return luaA_class_newindex_miss_property(L, NULL);
|
|
}
|
|
|
|
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80
|