Initial changes to get dfhack building on the Mac

develop
Timothy Collett 2012-05-24 11:31:20 -04:00
parent 20794ebf19
commit 24d221052b
17 changed files with 119 additions and 680 deletions

@ -117,7 +117,9 @@ ENDIF()
ADD_DEFINITIONS(-DPROTOBUF_USE_DLLS)
ADD_DEFINITIONS(-DLUA_BUILD_AS_DLL)
if(UNIX)
if(APPLE)
add_definitions(-D_DARWIN)
elseif(UNIX)
add_definitions(-D_LINUX)
elseif(WIN32)
add_definitions(-DWIN32)
@ -137,6 +139,10 @@ include_directories(depends/tinyxml)
include_directories(depends/tthread)
include_directories(${ZLIB_INCLUDE_DIRS})
include_directories(depends/clsocket/src)
if(APPLE)
include_directories(${CMAKE_INSTALL_PREFIX}/libs/SDL.framework/Headers)
SET(PROJECT_LIBS SDL)
endif()
add_subdirectory(depends)

@ -1 +1 @@
Subproject commit 49fa800615a4e5c872164bcb4122030d2ebda9cf
Subproject commit 27216d9a4be418729cb4671371b7309f0af558f1

@ -36,9 +36,6 @@ include/MiscUtils.h
include/Module.h
include/Pragma.h
include/MemAccess.h
include/SDL_events.h
include/SDL_keyboard.h
include/SDL_keysym.h
include/TileTypes.h
include/Types.h
include/VersionInfo.h
@ -223,6 +220,10 @@ ENDIF()
IF(UNIX)
SET(PROJECT_LIBS rt dl dfhack-md5 dfhack-tinyxml dfhack-tinythread)
IF(APPLE)
SET(PROJECT_LIBS dl dfhack-md5 dfhack-tinyxml dfhack-tinythread SDL)
# include_directories(${CMAKE_INSTALL_PREFIX}/libs/SDL.framework/Headers)
ENDIF()
ELSE(WIN32)
#FIXME: do we really need psapi?
SET(PROJECT_LIBS psapi dfhack-tinyxml dfhack-tinythread)
@ -255,6 +256,10 @@ ENDIF()
#effectively disables debug builds...
SET_TARGET_PROPERTIES(dfhack PROPERTIES DEBUG_POSTFIX "-debug" )
IF(APPLE)
TARGET_LINK_LIBRARIES(dfhack ${CMAKE_INSTALL_PREFIX}/libs/SDL.framework/SDL)
ENDIF()
TARGET_LINK_LIBRARIES(dfhack protobuf-lite clsocket lua ${PROJECT_LIBS})
SET_TARGET_PROPERTIES(dfhack PROPERTIES LINK_INTERFACE_LIBRARIES "")

@ -60,6 +60,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <errno.h>
#include <deque>
// George Vulov for MacOSX
#ifndef __LINUX__
#define TEMP_FAILURE_RETRY(expr) \
({ long int _res; \
do _res = (long int) (expr); \
while (_res == -1L && errno == EINTR); \
_res; })
#endif
#include "Console.h"
#include "Hooks.h"
using namespace DFHack;

@ -204,7 +204,7 @@ struct sortable
static std::string getLuaHelp(std::string path)
{
ifstream script(path);
ifstream script(path.c_str());
if (script.good())
{
@ -237,7 +237,7 @@ static std::map<string,string> listLuaScripts(std::string path)
static bool fileExists(std::string path)
{
ifstream script(path);
ifstream script(path.c_str());
return script.good();
}
@ -628,7 +628,7 @@ bool Core::loadScriptFile(color_ostream &out, string fname, bool silent)
{
if(!silent)
out << "Loading script at " << fname << std::endl;
ifstream script(fname);
ifstream script(fname.c_str());
if (script.good())
{
string command;
@ -1205,25 +1205,25 @@ bool Core::ncurses_wgetch(int in, int & out)
return true;
}
int Core::UnicodeAwareSym(const SDL::KeyboardEvent& ke)
int Core::UnicodeAwareSym(const SDL_KeyboardEvent& ke)
{
// Assume keyboard layouts don't change the order of numbers:
if( '0' <= ke.ksym.sym && ke.ksym.sym <= '9') return ke.ksym.sym;
if(SDL::K_F1 <= ke.ksym.sym && ke.ksym.sym <= SDL::K_F12) return ke.ksym.sym;
if( '0' <= ke.keysym.sym && ke.keysym.sym <= '9') return ke.keysym.sym;
if(SDLK_F1 <= ke.keysym.sym && ke.keysym.sym <= SDLK_F12) return ke.keysym.sym;
// These keys are mapped to the same control codes as Ctrl-?
switch (ke.ksym.sym) {
case SDL::K_RETURN:
case SDL::K_KP_ENTER:
case SDL::K_TAB:
case SDL::K_ESCAPE:
case SDL::K_DELETE:
return ke.ksym.sym;
switch (ke.keysym.sym) {
case SDLK_RETURN:
case SDLK_KP_ENTER:
case SDLK_TAB:
case SDLK_ESCAPE:
case SDLK_DELETE:
return ke.keysym.sym;
default:
break;
}
int unicode = ke.ksym.unicode;
int unicode = ke.keysym.unicode;
// convert Ctrl characters to their 0x40-0x5F counterparts:
if (unicode < ' ')
@ -1253,28 +1253,28 @@ int Core::UnicodeAwareSym(const SDL::KeyboardEvent& ke)
}
//MEMO: return false if event is consumed
int Core::SDL_Event(SDL::Event* ev)
int Core::DFH_SDL_Event(SDL_Event* ev)
{
// do NOT process events before we are ready.
if(!started) return true;
if(!ev)
return true;
if(ev && (ev->type == SDL::ET_KEYDOWN || ev->type == SDL::ET_KEYUP))
if(ev && (ev->type == SDL_KEYDOWN || ev->type == SDL_KEYUP))
{
SDL::KeyboardEvent * ke = (SDL::KeyboardEvent *)ev;
SDL_KeyboardEvent * ke = (SDL_KeyboardEvent *)ev;
if(ke->state == SDL::BTN_PRESSED && !hotkey_states[ke->ksym.sym])
if(ke->state == SDL_PRESSED && !hotkey_states[ke->keysym.sym])
{
hotkey_states[ke->ksym.sym] = true;
hotkey_states[ke->keysym.sym] = true;
int mod = 0;
if (ke->ksym.mod & SDL::KMOD_SHIFT) mod |= 1;
if (ke->ksym.mod & SDL::KMOD_CTRL) mod |= 2;
if (ke->ksym.mod & SDL::KMOD_ALT) mod |= 4;
if (ke->keysym.mod & KMOD_SHIFT) mod |= 1;
if (ke->keysym.mod & KMOD_CTRL) mod |= 2;
if (ke->keysym.mod & KMOD_ALT) mod |= 4;
// Use unicode so Windows gives the correct value for the
// user's Input Language
if((ke->ksym.unicode & 0xff80) == 0)
if((ke->keysym.unicode & 0xff80) == 0)
{
int key = UnicodeAwareSym(*ke);
SelectHotkey(key, mod);
@ -1282,12 +1282,12 @@ int Core::SDL_Event(SDL::Event* ev)
else
{
// Pretend non-ascii characters don't happen:
SelectHotkey(ke->ksym.sym, mod);
SelectHotkey(ke->keysym.sym, mod);
}
}
else if(ke->state == SDL::BTN_RELEASED)
else if(ke->state == SDL_RELEASED)
{
hotkey_states[ke->ksym.sym] = false;
hotkey_states[ke->keysym.sym] = false;
}
}
return true;
@ -1304,8 +1304,8 @@ bool Core::SelectHotkey(int sym, int modifiers)
while (screen->child)
screen = screen->child;
if (sym == SDL::K_KP_ENTER)
sym = SDL::K_RETURN;
if (sym == SDLK_KP_ENTER)
sym = SDLK_RETURN;
std::string cmd;
@ -1328,7 +1328,7 @@ bool Core::SelectHotkey(int sym, int modifiers)
if (cmd.empty()) {
// Check the hotkey keybindings
int idx = sym - SDL::K_F1;
int idx = sym - SDLK_F1;
if(idx >= 0 && idx < 8)
{
if (modifiers & 1)
@ -1383,13 +1383,13 @@ static bool parseKeySpec(std::string keyspec, int *psym, int *pmod, std::string
}
if (keyspec.size() == 1 && keyspec[0] >= 'A' && keyspec[0] <= 'Z') {
*psym = SDL::K_a + (keyspec[0]-'A');
*psym = SDLK_a + (keyspec[0]-'A');
return true;
} else if (keyspec.size() == 2 && keyspec[0] == 'F' && keyspec[1] >= '1' && keyspec[1] <= '9') {
*psym = SDL::K_F1 + (keyspec[1]-'1');
*psym = SDLK_F1 + (keyspec[1]-'1');
return true;
} else if (keyspec == "Enter") {
*psym = SDL::K_RETURN;
*psym = SDLK_RETURN;
return true;
} else
return false;

@ -65,13 +65,13 @@ DFhackCExport int egg_prerender(void)
}
// hook - called for each SDL event, returns 0 when the event has been consumed. 1 otherwise
DFhackCExport int egg_sdl_event(SDL::Event* event)
DFhackCExport int egg_sdl_event(SDL_Event* event)
{
// if the event is valid, intercept
if( event != 0 )
{
DFHack::Core & c = DFHack::Core::getInstance();
return c.SDL_Event(event);
return c.DFH_SDL_Event(event);
}
return true;
}

@ -38,16 +38,31 @@ distribution.
#include <string>
#include <map>
typedef struct interpose_s
{
void *new_func;
void *orig_func;
} interpose_t;
#include "DFHack.h"
#include "Core.h"
#include "Hooks.h"
#include <iostream>
static const interpose_t interposers[] __attribute__ ((section("__DATA, __interpose"))) =
{
{ (void *)DFH_SDL_Init, (void *)SDL_Init },
{ (void *)DFH_SDL_PollEvent, (void *)SDL_PollEvent },
{ (void *)DFH_SDL_Quit, (void *)SDL_Quit },
{ (void *)DFH_SDL_NumJoysticks, (void *)SDL_NumJoysticks },
};
/*******************************************************************************
* SDL part starts here *
*******************************************************************************/
// hook - called for each game tick (or more often)
DFhackCExport int SDL_NumJoysticks(void)
DFhackCExport int DFH_SDL_NumJoysticks(void)
{
DFHack::Core & c = DFHack::Core::getInstance();
return c.Update();
@ -55,23 +70,24 @@ DFhackCExport int SDL_NumJoysticks(void)
// hook - called at program exit
static void (*_SDL_Quit)(void) = 0;
DFhackCExport void SDL_Quit(void)
DFhackCExport void DFH_SDL_Quit(void)
{
DFHack::Core & c = DFHack::Core::getInstance();
c.Shutdown();
if(_SDL_Quit)
/*if(_SDL_Quit)
{
_SDL_Quit();
}
}*/
SDL_Quit();
}
// called by DF to check input events
static int (*_SDL_PollEvent)(SDL::Event* event) = 0;
DFhackCExport int SDL_PollEvent(SDL::Event* event)
static int (*_SDL_PollEvent)(SDL_Event* event) = 0;
DFhackCExport int DFH_SDL_PollEvent(SDL_Event* event)
{
pollevent_again:
// if SDL returns 0 here, it means there are no more events. return 0
int orig_return = _SDL_PollEvent(event);
int orig_return = SDL_PollEvent(event);
if(!orig_return)
return 0;
// otherwise we have an event to filter
@ -79,7 +95,7 @@ DFhackCExport int SDL_PollEvent(SDL::Event* event)
{
DFHack::Core & c = DFHack::Core::getInstance();
// if we consume the event, ask SDL for more.
if(!c.SDL_Event(event))
if(!c.DFH_SDL_Event(event))
goto pollevent_again;
}
return orig_return;
@ -111,20 +127,21 @@ DFhackCExport int wgetch(WINDOW *win)
// hook - called at program start, initialize some stuffs we'll use later
static int (*_SDL_Init)(uint32_t flags) = 0;
DFhackCExport int SDL_Init(uint32_t flags)
DFhackCExport int DFH_SDL_Init(uint32_t flags)
{
// reroute stderr
fprintf(stderr,"dfhack: attempting to hook in\n");
freopen("stderr.log", "w", stderr);
// we don't reroute stdout until we figure out if this should be done at all
// See: Console-linux.cpp
// find real functions
_SDL_Init = (int (*)( uint32_t )) dlsym(RTLD_NEXT, "SDL_Init");
_SDL_Quit = (void (*)( void )) dlsym(RTLD_NEXT, "SDL_Quit");
_SDL_PollEvent = (int (*)(SDL::Event*))dlsym(RTLD_NEXT,"SDL_PollEvent");
// find real functions -- unnecessary in Mac OS X
// _SDL_Init = (int (*)( uint32_t )) dlsym(RTLD_NEXT, "SDL_Init");
// _SDL_Quit = (void (*)( void )) dlsym(RTLD_NEXT, "SDL_Quit");
// _SDL_PollEvent = (int (*)(SDL::Event*))dlsym(RTLD_NEXT,"SDL_PollEvent");
// check if we got them
if(_SDL_Init && _SDL_Quit && _SDL_PollEvent)
/* if(_SDL_Init && _SDL_Quit && _SDL_PollEvent)
{
fprintf(stderr,"dfhack: hooking successful\n");
}
@ -133,11 +150,11 @@ DFhackCExport int SDL_Init(uint32_t flags)
// bail, this would be a disaster otherwise
fprintf(stderr,"dfhack: something went horribly wrong\n");
exit(1);
}
}*/
/*
DFHack::Core & c = DFHack::Core::getInstance();
c.Init();
*/
int ret = _SDL_Init(flags);
int ret = SDL_Init(flags);
return ret;
}

@ -431,7 +431,7 @@ DFhackCExport int SDL_PollEvent(SDL::Event* event)
{
DFHack::Core & c = DFHack::Core::getInstance();
// if we consume the event, ask SDL for more.
if(!c.SDL_Event(event))
if(!c.DFH_SDL_Event(event))
goto pollevent_again;
}
return orig_return;

@ -84,16 +84,16 @@ namespace DFHack
// Better than tracking some weird variables all over the place.
class DFHACK_EXPORT Core
{
friend int ::SDL_NumJoysticks(void);
friend void ::SDL_Quit(void);
friend int ::SDL_PollEvent(SDL::Event *);
friend int ::SDL_Init(uint32_t flags);
friend int ::DFH_SDL_NumJoysticks(void);
friend void ::DFH_SDL_Quit(void);
friend int ::DFH_SDL_PollEvent(SDL_Event *);
friend int ::DFH_SDL_Init(uint32_t flags);
friend int ::wgetch(WINDOW * w);
friend int ::egg_init(void);
friend int ::egg_shutdown(void);
friend int ::egg_tick(void);
friend int ::egg_prerender(void);
friend int ::egg_sdl_event(SDL::Event* event);
friend int ::egg_sdl_event(SDL_Event* event);
friend int ::egg_curses_event(int orig_return);
public:
/// Get the single Core instance or make one.
@ -170,7 +170,7 @@ namespace DFHack
int Update (void);
int TileUpdate (void);
int Shutdown (void);
int SDL_Event(SDL::Event* event);
int DFH_SDL_Event(SDL_Event* event);
bool ncurses_wgetch(int in, int & out);
void onUpdate(color_ostream &out);
@ -215,7 +215,7 @@ namespace DFHack
tthread::mutex * HotkeyMutex;
tthread::condition_variable * HotkeyCond;
int UnicodeAwareSym(const SDL::KeyboardEvent& ke);
int UnicodeAwareSym(const SDL_KeyboardEvent& ke);
bool SelectHotkey(int key, int modifiers);
// for state change tracking

@ -33,6 +33,8 @@ distribution.
#include <string>
#include <stdint.h>
#include "SDL.h"
// function and variable pointer... we don't try to understand what SDL does here
typedef void * fPtr;
typedef void * vPtr;
@ -44,10 +46,10 @@ namespace SDL
// these functions are here because they call into DFHack::Core and therefore need to
// be declared as friend functions/known
DFhackCExport int SDL_NumJoysticks(void);
DFhackCExport void SDL_Quit(void);
DFhackCExport int SDL_PollEvent(SDL::Event* event);
DFhackCExport int SDL_Init(uint32_t flags);
DFhackCExport int DFH_SDL_NumJoysticks(void);
DFhackCExport void DFH_SDL_Quit(void);
DFhackCExport int DFH_SDL_PollEvent(SDL_Event* event);
DFhackCExport int DFH_SDL_Init(uint32_t flags);
DFhackCExport int wgetch(WINDOW * win);
// hook - called early from DF's main()
@ -63,7 +65,7 @@ DFhackCExport int egg_tick(void);
DFhackCExport int egg_prerender(void);
// hook - called for each SDL event, can filter both the event and the return value
DFhackCExport int egg_sdl_event(SDL::Event* event);
DFhackCExport int egg_sdl_event(SDL_Event* event);
// hook - ncurses event. return -1 to consume
DFhackCExport int egg_curses_event(int orig_return);

@ -1,210 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
// Fake - only structs. Shamelessly pilfered from the SDL library.
// Needed for processing its event types without polluting our namespaces with C garbage
#pragma once
#include "SDL_keyboard.h"
namespace SDL
{
enum ButtonState
{
BTN_RELEASED = 0,
BTN_PRESSED = 1
};
/** Event enumerations */
enum EventType
{
ET_NOEVENT = 0, /**< Unused (do not remove) */
ET_ACTIVEEVENT, /**< Application loses/gains visibility */
ET_KEYDOWN, /**< Keys pressed */
ET_KEYUP, /**< Keys released */
ET_MOUSEMOTION, /**< Mouse moved */
ET_MOUSEBUTTONDOWN, /**< Mouse button pressed */
ET_MOUSEBUTTONUP, /**< Mouse button released */
ET_JOYAXISMOTION, /**< Joystick axis motion */
ET_JOYBALLMOTION, /**< Joystick trackball motion */
ET_JOYHATMOTION, /**< Joystick hat position change */
ET_JOYBUTTONDOWN, /**< Joystick button pressed */
ET_JOYBUTTONUP, /**< Joystick button released */
ET_QUIT, /**< User-requested quit */
ET_SYSWMEVENT, /**< System specific event */
ET_EVENT_RESERVEDA, /**< Reserved for future use.. */
ET_EVENT_RESERVEDB, /**< Reserved for future use.. */
ET_VIDEORESIZE, /**< User resized video mode */
ET_VIDEOEXPOSE, /**< Screen needs to be redrawn */
ET_EVENT_RESERVED2, /**< Reserved for future use.. */
ET_EVENT_RESERVED3, /**< Reserved for future use.. */
ET_EVENT_RESERVED4, /**< Reserved for future use.. */
ET_EVENT_RESERVED5, /**< Reserved for future use.. */
ET_EVENT_RESERVED6, /**< Reserved for future use.. */
ET_EVENT_RESERVED7, /**< Reserved for future use.. */
/** Events ET_USEREVENT through ET_MAXEVENTS-1 are for your use */
ET_USEREVENT = 24,
/** This last event is only for bounding internal arrays
* It is the number of bits in the event mask datatype -- Uint32
*/
ET_NUMEVENTS = 32
};
/** Application visibility event structure */
struct ActiveEvent
{
uint8_t type; /**< ET_ACTIVEEVENT */
uint8_t gain; /**< Whether given states were gained or lost (1/0) */
uint8_t state; /**< A mask of the focus states */
};
/** Keyboard event structure */
struct KeyboardEvent
{
uint8_t type; /**< ET_KEYDOWN or ET_KEYUP */
uint8_t which; /**< The keyboard device index */
uint8_t state; /**< BTN_PRESSED or BTN_RELEASED */
keysym ksym;
};
/** Mouse motion event structure */
struct MouseMotionEvent
{
uint8_t type; /**< ET_MOUSEMOTION */
uint8_t which; /**< The mouse device index */
uint8_t state; /**< The current button state */
uint16_t x, y; /**< The X/Y coordinates of the mouse */
int16_t xrel; /**< The relative motion in the X direction */
int16_t yrel; /**< The relative motion in the Y direction */
};
/** Mouse button event structure */
struct MouseButtonEvent
{
uint8_t type; /**< ET_MOUSEBUTTONDOWN or ET_MOUSEBUTTONUP */
uint8_t which; /**< The mouse device index */
uint8_t button; /**< The mouse button index */
uint8_t state; /**< BTN_PRESSED or BTN_RELEASED */
uint16_t x, y; /**< The X/Y coordinates of the mouse at press time */
};
/** Joystick axis motion event structure */
struct JoyAxisEvent
{
uint8_t type; /**< ET_JOYAXISMOTION */
uint8_t which; /**< The joystick device index */
uint8_t axis; /**< The joystick axis index */
int16_t value; /**< The axis value (range: -32768 to 32767) */
};
/** Joystick trackball motion event structure */
struct JoyBallEvent
{
uint8_t type; /**< ET_JOYBALLMOTION */
uint8_t which; /**< The joystick device index */
uint8_t ball; /**< The joystick trackball index */
int16_t xrel; /**< The relative motion in the X direction */
int16_t yrel; /**< The relative motion in the Y direction */
};
/** Joystick hat position change event structure */
struct JoyHatEvent
{
uint8_t type; /**< ET_JOYHATMOTION */
uint8_t which; /**< The joystick device index */
uint8_t hat; /**< The joystick hat index */
uint8_t value; /**< The hat position value:
* SDL_HAT_LEFTUP SDL_HAT_UP SDL_HAT_RIGHTUP
* SDL_HAT_LEFT SDL_HAT_CENTERED SDL_HAT_RIGHT
* SDL_HAT_LEFTDOWN SDL_HAT_DOWN SDL_HAT_RIGHTDOWN
* Note that zero means the POV is centered.
*/
};
/** Joystick button event structure */
struct JoyButtonEvent
{
uint8_t type; /**< ET_JOYBUTTONDOWN or ET_JOYBUTTONUP */
uint8_t which; /**< The joystick device index */
uint8_t button; /**< The joystick button index */
uint8_t state; /**< BTN_PRESSED or BTN_RELEASED */
};
/** The "window resized" event
* When you get this event, you are responsible for setting a new video
* mode with the new width and height.
*/
struct ResizeEvent
{
uint8_t type; /**< ET_VIDEORESIZE */
int w; /**< New width */
int h; /**< New height */
};
/** The "screen redraw" event */
struct ExposeEvent
{
uint8_t type; /**< ET_VIDEOEXPOSE */
};
/** The "quit requested" event */
struct QuitEvent
{
uint8_t type; /**< ET_QUIT */
};
/** A user-defined event type */
struct UserEvent
{
uint8_t type; /**< ETL_USEREVENT through ET_NUMEVENTS-1 */
int code; /**< User defined event code */
void *data1; /**< User defined data pointer */
void *data2; /**< User defined data pointer */
};
/** If you want to use this event, you should include SDL_syswm.h */
struct SysWMmsg;
struct SysWMEvent
{
uint8_t type;
SysWMmsg *msg;
};
/** General event structure */
union Event
{
uint8_t type;
ActiveEvent active;
KeyboardEvent key;
MouseMotionEvent motion;
MouseButtonEvent button;
JoyAxisEvent jaxis;
JoyBallEvent jball;
JoyHatEvent jhat;
JoyButtonEvent jbutton;
ResizeEvent resize;
ExposeEvent expose;
QuitEvent quit;
UserEvent user;
SysWMEvent syswm;
};
}

@ -1,61 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
// Fake - only structs. Shamelessly pilfered from the SDL library.
// Needed for processing its event types without polluting our namespaces with C garbage
#pragma once
#include "SDL_keysym.h"
#include <stdint.h>
namespace SDL
{
/** Keysym structure
*
* - The scancode is hardware dependent, and should not be used by general
* applications. If no hardware scancode is available, it will be 0.
*
* - The 'unicode' translated character is only available when character
* translation is enabled by the SDL_EnableUNICODE() API. If non-zero,
* this is a UNICODE character corresponding to the keypress. If the
* high 9 bits of the character are 0, then this maps to the equivalent
* ASCII character:
* @code
* char ch;
* if ( (keysym.unicode & 0xFF80) == 0 ) {
* ch = keysym.unicode & 0x7F;
* } else {
* An international character..
* }
* @endcode
*/
typedef struct keysym
{
uint8_t scancode; /**< hardware specific scancode */
Key sym; /**< SDL virtual keysym */
Mod mod; /**< current key modifiers */
uint16_t unicode; /**< translated character */
} keysym;
/** This is the mask which refers to all hotkey bindings */
#define ALL_HOTKEYS 0xFFFFFFFF
}

@ -1,329 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
// Fake - only structs. Shamelessly pilfered from the SDL library.
// Needed for processing its event types without polluting our namespaces with C garbage
#pragma once
namespace SDL
{
/** What we really want is a mapping of every raw key on the keyboard.
* To support international keyboards, we use the range 0xA1 - 0xFF
* as international virtual keycodes. We'll follow in the footsteps of X11...
* @brief The names of the keys
*/
enum Key
{
/** @name ASCII mapped keysyms
* The keyboard syms have been cleverly chosen to map to ASCII
*/
/*@{*/
K_UNKNOWN = 0,
K_FIRST = 0,
K_BACKSPACE = 8,
K_TAB = 9,
K_CLEAR = 12,
K_RETURN = 13,
K_PAUSE = 19,
K_ESCAPE = 27,
K_SPACE = 32,
K_EXCLAIM = 33,
K_QUOTEDBL = 34,
K_HASH = 35,
K_DOLLAR = 36,
K_AMPERSAND = 38,
K_QUOTE = 39,
K_LEFTPAREN = 40,
K_RIGHTPAREN = 41,
K_ASTERISK = 42,
K_PLUS = 43,
K_COMMA = 44,
K_MINUS = 45,
K_PERIOD = 46,
K_SLASH = 47,
K_0 = 48,
K_1 = 49,
K_2 = 50,
K_3 = 51,
K_4 = 52,
K_5 = 53,
K_6 = 54,
K_7 = 55,
K_8 = 56,
K_9 = 57,
K_COLON = 58,
K_SEMICOLON = 59,
K_LESS = 60,
K_EQUALS = 61,
K_GREATER = 62,
K_QUESTION = 63,
K_AT = 64,
/*
Skip uppercase letters
*/
K_LEFTBRACKET = 91,
K_BACKSLASH = 92,
K_RIGHTBRACKET = 93,
K_CARET = 94,
K_UNDERSCORE = 95,
K_BACKQUOTE = 96,
K_a = 97,
K_b = 98,
K_c = 99,
K_d = 100,
K_e = 101,
K_f = 102,
K_g = 103,
K_h = 104,
K_i = 105,
K_j = 106,
K_k = 107,
K_l = 108,
K_m = 109,
K_n = 110,
K_o = 111,
K_p = 112,
K_q = 113,
K_r = 114,
K_s = 115,
K_t = 116,
K_u = 117,
K_v = 118,
K_w = 119,
K_x = 120,
K_y = 121,
K_z = 122,
K_DELETE = 127,
/* End of ASCII mapped keysyms */
/*@}*/
/** @name International keyboard syms */
/*@{*/
K_WORLD_0 = 160, /* 0xA0 */
K_WORLD_1 = 161,
K_WORLD_2 = 162,
K_WORLD_3 = 163,
K_WORLD_4 = 164,
K_WORLD_5 = 165,
K_WORLD_6 = 166,
K_WORLD_7 = 167,
K_WORLD_8 = 168,
K_WORLD_9 = 169,
K_WORLD_10 = 170,
K_WORLD_11 = 171,
K_WORLD_12 = 172,
K_WORLD_13 = 173,
K_WORLD_14 = 174,
K_WORLD_15 = 175,
K_WORLD_16 = 176,
K_WORLD_17 = 177,
K_WORLD_18 = 178,
K_WORLD_19 = 179,
K_WORLD_20 = 180,
K_WORLD_21 = 181,
K_WORLD_22 = 182,
K_WORLD_23 = 183,
K_WORLD_24 = 184,
K_WORLD_25 = 185,
K_WORLD_26 = 186,
K_WORLD_27 = 187,
K_WORLD_28 = 188,
K_WORLD_29 = 189,
K_WORLD_30 = 190,
K_WORLD_31 = 191,
K_WORLD_32 = 192,
K_WORLD_33 = 193,
K_WORLD_34 = 194,
K_WORLD_35 = 195,
K_WORLD_36 = 196,
K_WORLD_37 = 197,
K_WORLD_38 = 198,
K_WORLD_39 = 199,
K_WORLD_40 = 200,
K_WORLD_41 = 201,
K_WORLD_42 = 202,
K_WORLD_43 = 203,
K_WORLD_44 = 204,
K_WORLD_45 = 205,
K_WORLD_46 = 206,
K_WORLD_47 = 207,
K_WORLD_48 = 208,
K_WORLD_49 = 209,
K_WORLD_50 = 210,
K_WORLD_51 = 211,
K_WORLD_52 = 212,
K_WORLD_53 = 213,
K_WORLD_54 = 214,
K_WORLD_55 = 215,
K_WORLD_56 = 216,
K_WORLD_57 = 217,
K_WORLD_58 = 218,
K_WORLD_59 = 219,
K_WORLD_60 = 220,
K_WORLD_61 = 221,
K_WORLD_62 = 222,
K_WORLD_63 = 223,
K_WORLD_64 = 224,
K_WORLD_65 = 225,
K_WORLD_66 = 226,
K_WORLD_67 = 227,
K_WORLD_68 = 228,
K_WORLD_69 = 229,
K_WORLD_70 = 230,
K_WORLD_71 = 231,
K_WORLD_72 = 232,
K_WORLD_73 = 233,
K_WORLD_74 = 234,
K_WORLD_75 = 235,
K_WORLD_76 = 236,
K_WORLD_77 = 237,
K_WORLD_78 = 238,
K_WORLD_79 = 239,
K_WORLD_80 = 240,
K_WORLD_81 = 241,
K_WORLD_82 = 242,
K_WORLD_83 = 243,
K_WORLD_84 = 244,
K_WORLD_85 = 245,
K_WORLD_86 = 246,
K_WORLD_87 = 247,
K_WORLD_88 = 248,
K_WORLD_89 = 249,
K_WORLD_90 = 250,
K_WORLD_91 = 251,
K_WORLD_92 = 252,
K_WORLD_93 = 253,
K_WORLD_94 = 254,
K_WORLD_95 = 255, /* 0xFF */
/*@}*/
/** @name Numeric keypad */
/*@{*/
K_KP0 = 256,
K_KP1 = 257,
K_KP2 = 258,
K_KP3 = 259,
K_KP4 = 260,
K_KP5 = 261,
K_KP6 = 262,
K_KP7 = 263,
K_KP8 = 264,
K_KP9 = 265,
K_KP_PERIOD = 266,
K_KP_DIVIDE = 267,
K_KP_MULTIPLY = 268,
K_KP_MINUS = 269,
K_KP_PLUS = 270,
K_KP_ENTER = 271,
K_KP_EQUALS = 272,
/*@}*/
/** @name Arrows + Home/End pad */
/*@{*/
K_UP = 273,
K_DOWN = 274,
K_RIGHT = 275,
K_LEFT = 276,
K_INSERT = 277,
K_HOME = 278,
K_END = 279,
K_PAGEUP = 280,
K_PAGEDOWN = 281,
/*@}*/
/** @name Function keys */
/*@{*/
K_F1 = 282,
K_F2 = 283,
K_F3 = 284,
K_F4 = 285,
K_F5 = 286,
K_F6 = 287,
K_F7 = 288,
K_F8 = 289,
K_F9 = 290,
K_F10 = 291,
K_F11 = 292,
K_F12 = 293,
K_F13 = 294,
K_F14 = 295,
K_F15 = 296,
/*@}*/
/** @name Key state modifier keys */
/*@{*/
K_NUMLOCK = 300,
K_CAPSLOCK = 301,
K_SCROLLOCK = 302,
K_RSHIFT = 303,
K_LSHIFT = 304,
K_RCTRL = 305,
K_LCTRL = 306,
K_RALT = 307,
K_LALT = 308,
K_RMETA = 309,
K_LMETA = 310,
K_LSUPER = 311, /**< Left "Windows" key */
K_RSUPER = 312, /**< Right "Windows" key */
K_MODE = 313, /**< "Alt Gr" key */
K_COMPOSE = 314, /**< Multi-key compose key */
/*@}*/
/** @name Miscellaneous function keys */
/*@{*/
K_HELP = 315,
K_PRINT = 316,
K_SYSREQ = 317,
K_BREAK = 318,
K_MENU = 319,
K_POWER = 320, /**< Power Macintosh power key */
K_EURO = 321, /**< Some european keyboards */
K_UNDO = 322, /**< Atari keyboard has Undo */
/*@}*/
/* Add any other keys here */
K_LAST
};
/** Enumeration of valid key mods (possibly OR'd together) */
enum Mod {
KMOD_NONE = 0x0000,
KMOD_LSHIFT= 0x0001,
KMOD_RSHIFT= 0x0002,
KMOD_LCTRL = 0x0040,
KMOD_RCTRL = 0x0080,
KMOD_LALT = 0x0100,
KMOD_RALT = 0x0200,
KMOD_LMETA = 0x0400,
KMOD_RMETA = 0x0800,
KMOD_NUM = 0x1000,
KMOD_CAPS = 0x2000,
KMOD_MODE = 0x4000,
KMOD_RESERVED = 0x8000,
KMOD_CTRL = (KMOD_LCTRL|KMOD_RCTRL),
KMOD_SHIFT = (KMOD_LSHIFT|KMOD_RSHIFT),
KMOD_ALT = (KMOD_LALT|KMOD_RALT),
KMOD_META = (KMOD_LMETA|KMOD_RMETA)
};
}

@ -907,7 +907,7 @@ void Gui::showAnnouncement(std::string message, int color, bool bright)
new_rep->flags.bits.continuation = continued;
new_rep->flags.bits.announcement = true;
int size = std::min(message.size(), 73U);
int size = std::min(message.size(), (size_t)73);
new_rep->text = message.substr(0, size);
message = message.substr(size);

@ -213,7 +213,7 @@ command_result export_dwarves (color_ostream &con, std::vector <std::string> & p
return CR_OK;
}
ofstream outf(filename);
ofstream outf(filename.c_str());
if (!outf) {
con.printerr("Failed to open file %s\n", filename.c_str());
return CR_FAILURE;

@ -78,7 +78,7 @@ DFhackCExport command_result plugin_shutdown ( color_ostream &out )
static string brushname = "point";
static string mode="magma";
static string flowmode="f+";
static string setmode ="s.";
static string _setmode ="s.";
static unsigned int amount = 7;
static int width = 1, height = 1, z_levels = 1;
@ -120,7 +120,7 @@ command_result df_liquids (color_ostream &out_, vector <string> & parameters)
str <<"[" << mode << ":" << brushname;
if (brushname == "range")
str << "(w" << width << ":h" << height << ":z" << z_levels << ")";
str << ":" << amount << ":" << flowmode << ":" << setmode << "]#";
str << ":" << amount << ":" << flowmode << ":" << _setmode << "]#";
if(out.lineedit(str.str(),input,liquids_hist) == -1)
return CR_FAILURE;
liquids_hist.add(input);
@ -246,15 +246,15 @@ command_result df_liquids (color_ostream &out_, vector <string> & parameters)
}
else if(command == "s+")
{
setmode = "s+";
_setmode = "s+";
}
else if(command == "s-")
{
setmode = "s-";
_setmode = "s-";
}
else if(command == "s.")
{
setmode = "s.";
_setmode = "s.";
}
// blah blah, bad code, bite me.
else if(command == "0")
@ -301,7 +301,7 @@ command_result df_liquids_here (color_ostream &out, vector <string> & parameters
out << "[" << mode << ":" << brushname;
if (brushname == "range")
out << "(w" << width << ":h" << height << ":z" << z_levels << ")";
out << ":" << amount << ":" << flowmode << ":" << setmode << "]\n";
out << ":" << amount << ":" << flowmode << ":" << _setmode << "]\n";
return df_liquids_execute(out);
}
@ -457,16 +457,16 @@ command_result df_liquids_execute(color_ostream &out)
df::tile_liquid old_liquid = des.bits.liquid_type;
df::tile_liquid new_liquid = old_liquid;
// Compute new liquid type and amount
if(setmode == "s.")
if(_setmode == "s.")
{
new_amount = amount;
}
else if(setmode == "s+")
else if(_setmode == "s+")
{
if(old_amount < amount)
new_amount = amount;
}
else if(setmode == "s-")
else if(_setmode == "s-")
{
if (old_amount > amount)
new_amount = amount;

@ -124,7 +124,7 @@ command_result mapexport (color_ostream &out, std::vector <std::string> & parame
if (filename.rfind(".dfmap") == std::string::npos) filename += ".dfmap";
out << "Writing to " << filename << "..." << std::endl;
std::ofstream output_file(filename, std::ios::out | std::ios::trunc | std::ios::binary);
std::ofstream output_file(filename.c_str(), std::ios::out | std::ios::trunc | std::ios::binary);
if (!output_file.is_open())
{
out.printerr("Couldn't open the output file.\n");