void playsingle_controller::init_gui()
{
uint32_t start = SDL_GetTicks();
LOG_NG << "Initializing GUI... " << (SDL_GetTicks() - ticks_) << "\n";
play_controller::init_gui();
uint32_t end_parent_init_gui = SDL_GetTicks();
posix_print("playsingle_controller::init_gui, play_controller::init_gui(), used time: %u ms\n", end_parent_init_gui - start);
if (human_team_ != -1) {
gui_->scroll_to_tile(map_.starting_position(human_team_ + 1), game_display::WARP);
}
gui_->scroll_to_tile(map_.starting_position(1), game_display::WARP);
if (tent::mode != TOWER_MODE) {
gui_->set_current_list_type(game_display::taccess_list::TROOP);
} else {
gui_->set_current_list_type(game_display::taccess_list::HERO);
}
uint32_t end_scroll_to_tile = SDL_GetTicks();
posix_print("playsingle_controller::init_gui, scroll_to_tile, used time: %u ms\n", end_scroll_to_tile - end_parent_init_gui);
update_locker lock_display(gui_->video(),recorder.is_skipping());
events::raise_draw_event();
gui_->draw();
for(std::vector<team>::iterator t = teams_.begin(); t != teams_.end(); ++t) {
::clear_shroud(t - teams_.begin() + 1);
}
uint32_t end_draw = SDL_GetTicks();
posix_print("playsingle_controller::init_gui, gui_->draw, used time: %u ms\n", end_draw - end_scroll_to_tile);
}
void playsingle_controller::init_gui(){
LOG_NG << "Initializing GUI... " << (SDL_GetTicks() - ticks()) << "\n";
play_controller::init_gui();
// Scroll to the starting position of the first team. If there is a
// human team, use that team; otherwise use team 1. If the map defines
// a starting position for the selected team, scroll to that tile. Note
// this often does not matter since many scenario start with messages,
// which will usually scroll to the speaker. Also note that the map
// does not necessarily define the starting positions. While usually
// best to use the map, the scenarion may explicitly set the positions,
// overriding those found in the map (if any).
{
int scroll_team = gamestate().first_human_team_ + 1;
if (scroll_team == 0) {
scroll_team = 1;
}
map_location loc(gamestate().board_.map().starting_position(scroll_team));
if ((loc.x >= 0) && (loc.y >= 0)) {
gui_->scroll_to_tile(loc, game_display::WARP);
}
}
update_locker lock_display(gui_->video(), is_skipping_replay());
gui_->draw();
get_hotkey_command_executor()->set_button_state();
events::raise_draw_event();
}
void playsingle_controller::init_gui()
{
uint32_t start = SDL_GetTicks();
LOG_NG << "Initializing GUI... " << (SDL_GetTicks() - ticks_) << "\n";
play_controller::init_gui();
uint32_t end_parent_init_gui = SDL_GetTicks();
posix_print("playsingle_controller::init_gui, play_controller::init_gui(), used time: %u ms\n", end_parent_init_gui - start);
if (human_team_ != -1) {
gui_->scroll_to_tile(map_.starting_position(human_team_ + 1), game_display::WARP);
}
gui_->scroll_to_tile(map_.starting_position(1), game_display::WARP);
if (tent::mode == mode_tag::TOWER || tent::mode == mode_tag::LAYOUT) {
gui_->set_current_list_type(game_display::taccess_list::HERO);
} else {
gui_->set_current_list_type(game_display::taccess_list::TROOP);
}
{
int ii = 0;
// gui_->set_current_list_type(game_display::taccess_list::TROOP);
}
uint32_t end_scroll_to_tile = SDL_GetTicks();
posix_print("playsingle_controller::init_gui, scroll_to_tile, used time: %u ms\n", end_scroll_to_tile - end_parent_init_gui);
update_locker lock_display(gui_->video(),recorder.is_skipping());
events::raise_draw_event();
gui_->draw();
for(std::vector<team>::iterator t = teams_.begin(); t != teams_.end(); ++t) {
::clear_shroud(t - teams_.begin() + 1);
}
gui_->refresh_access_troops(human_team_, game_display::REFRESH_RELOAD);
uint32_t end_draw = SDL_GetTicks();
posix_print("playsingle_controller::init_gui, gui_->draw, used time: %u ms\n", end_draw - end_scroll_to_tile);
if (tent::mode == mode_tag::SIEGE) {
refresh_endturn_button(*gui_, "buttons/ctrl-pause2.png");
gui_->set_theme_object_active("endturn", true);
teams_[human_team_].set_objectives_changed(false);
}
if (lobby->chat.ready()) {
refresh_chat_button(*gui_, "misc/network-disconnected.png");
}
tlobby::thandler::join();
}
void playsingle_controller::init_gui(){
LOG_NG << "Initializing GUI... " << (SDL_GetTicks() - ticks_) << "\n";
play_controller::init_gui();
if(first_human_team_ != -1) {
gui_->scroll_to_tile(map_.starting_position(first_human_team_ + 1), game_display::WARP);
}
gui_->scroll_to_tile(map_.starting_position(1), game_display::WARP);
update_locker lock_display(gui_->video(),recorder.is_skipping());
events::raise_draw_event();
gui_->draw();
}
void playsingle_controller::init_gui(){
LOG_NG << "Initializing GUI... " << (SDL_GetTicks() - ticks()) << "\n";
play_controller::init_gui();
if(gamestate().first_human_team_ != -1) {
gui_->scroll_to_tile(gamestate().board_.map().starting_position(gamestate().first_human_team_ + 1), game_display::WARP);
}
gui_->scroll_to_tile(gamestate().board_.map().starting_position(1), game_display::WARP);
update_locker lock_display(gui_->video(), is_skipping_replay());
gui_->draw();
get_hotkey_command_executor()->set_button_state();
events::raise_draw_event();
}
void replay_controller::init_gui(){
DBG_NG << "Initializing GUI... " << (SDL_GetTicks() - ticks_) << "\n";
play_controller::init_gui();
if (show_team_)
gui_->set_team(show_team_ - 1, show_everything_);
else
gui_->set_team(0, show_everything_);
gui_->scroll_to_leader(units_, player_number_, display::WARP);
update_locker lock_display((*gui_).video(),false);
for(std::vector<team>::iterator t = teams_.begin(); t != teams_.end(); ++t) {
t->reset_objectives_changed();
}
}
void playsingle_controller::init_gui(){
LOG_NG << "Initializing GUI... " << (SDL_GetTicks() - ticks_) << "\n";
play_controller::init_gui();
if(first_human_team_ != -1) {
gui_->scroll_to_tile(map_.starting_position(first_human_team_ + 1), game_display::WARP);
}
gui_->scroll_to_tile(map_.starting_position(1), game_display::WARP);
update_locker lock_display(gui_->video(),recorder.is_skipping());
events::raise_draw_event();
gui_->draw();
for(std::vector<team>::iterator t = teams_.begin(); t != teams_.end(); ++t) {
::clear_shroud(t - teams_.begin() + 1);
}
}
void replay_controller::init_gui(){
DBG_NG << "Initializing GUI... " << (SDL_GetTicks() - ticks_) << "\n";
play_controller::init_gui();
if (show_team_)
gui_->set_team(show_team_ - 1, show_everything_);
else
gui_->set_team(0, show_everything_);
gui_->scroll_to_leader(player_number_, display::WARP);
update_locker lock_display((*gui_).video(),false);
BOOST_FOREACH(const team & t, gamestate_.board_.teams()) {
t.reset_objectives_changed();
}
update_replay_ui();
}
void play_controller::fire_prestart()
{
// pre-start events must be executed before any GUI operation,
// as those may cause the display to be refreshed.
update_locker lock_display(gui_->video());
gamestate().gamedata_.set_phase(game_data::PRESTART);
// Fire these right before prestart events, to catch only the units sides
// have started with.
for (const unit& u : gamestate().board_.units()) {
pump().fire("unit_placed", map_location(u.get_location()));
}
pump().fire("prestart");
// prestart event may modify start turn with WML, reflect any changes.
gamestate().gamedata_.get_variable("turn_number") = int(turn());
}
static void _clippy_copy_to_sys(int do_sel)
{
int j;
char *dst;
char *freeme;
#if defined(__QNXNTO__)
PhClipboardHdr clheader = {Ph_CLIPBOARD_TYPE_TEXT, 0, NULL};
char *tmp;
int *cldata;
int status;
#endif
freeme = NULL;
if (!_current_selection) {
dst = NULL;
j = 0;
} else
#if defined(WIN32)
j = strlen(_current_selection);
#else
if (has_sys_clip) {
int i;
/* convert to local */
freeme = dst = malloc(strlen(_current_selection)+4);
if (!dst) return;
for (i = j = 0; _current_selection[i]; i++) {
dst[j] = _current_selection[i];
if (dst[j] != '\r') j++;
}
dst[j] = '\0';
} else {
dst = NULL;
j = 0;
}
#endif
#if defined(USE_X11)
if (has_sys_clip) {
lock_display();
if (!dst) dst = (char *) ""; /* blah */
if (j < 0) j = 0;
if (do_sel) {
if (XGetSelectionOwner(SDL_Display, XA_PRIMARY) != SDL_Window) {
XSetSelectionOwner(SDL_Display, XA_PRIMARY, SDL_Window, CurrentTime);
}
XChangeProperty(SDL_Display,
DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER1, XA_STRING, 8,
PropModeReplace, (unsigned char *)dst, j);
} else {
if (XGetSelectionOwner(SDL_Display, atom_clip) != SDL_Window) {
XSetSelectionOwner(SDL_Display, atom_clip, SDL_Window, CurrentTime);
}
XChangeProperty(SDL_Display,
DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER0, XA_STRING, 8,
PropModeReplace, (unsigned char *)dst, j);
XChangeProperty(SDL_Display,
DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER1, XA_STRING, 8,
PropModeReplace, (unsigned char *)dst, j);
}
unlock_display();
}
#elif defined(WIN32)
if (!do_sel && OpenClipboard(SDL_Window)) {
_hmem = GlobalAlloc((GMEM_MOVEABLE|GMEM_DDESHARE), j+1);
if (_hmem) {
dst = (char *)GlobalLock(_hmem);
if (dst) {
/* this seems wrong, but msdn does this */
memcpy(dst, _current_selection, j);
dst[j] = '\0';
GlobalUnlock(_hmem);
EmptyClipboard();
SetClipboardData(CF_TEXT, _hmem);
}
}
CloseClipboard();
_hmem = NULL;
dst = 0;
}
#elif defined(__QNXNTO__)
if (!do_sel) {
tmp = (char *)malloc(j+4);
if (!tmp) {
cldata=(int*)tmp;
*cldata = Ph_CL_TEXT;
if (dst) memcpy(tmp+4, dst, j);
clheader.data = tmp;
#if (NTO_VERSION < 620)
if (clheader.length > 65535) clheader.length=65535;
#endif
clheader.length = j + 4;
#if (NTO_VERSION < 620)
PhClipboardCopy(inputgroup, 1, &clheader);
#else
PhClipboardWrite(inputgroup, 1, &clheader);
#endif
free(tmp);
}
}
#elif defined(MACOSX)
if (!do_sel) macosx_clippy_put(_current_clipboard);
#else
// some other system -- linux without x11, maybe
// pretend we used the param to silence warnings
(void) do_sel;
#endif
if (freeme)
free(freeme);
}
static char *_internal_clippy_paste(int cb)
{
#if defined(MACOSX)
char *src;
#endif
#if defined(USE_X11)
Window owner;
int getme;
#elif defined(WIN32)
char *src;
int clen;
#elif defined(__QNXNTO__)
void *clhandle;
PhClipHeader *clheader;
int *cldata;
#endif
if (has_sys_clip) {
#if defined(USE_X11)
if (cb == CLIPPY_SELECT) {
getme = XA_PRIMARY;
} else {
getme = atom_clip;
}
lock_display();
owner = XGetSelectionOwner(SDL_Display, getme);
unlock_display();
if (owner == None || owner == SDL_Window) {
/* fall through to default implementation */
} else {
lock_display();
XConvertSelection(SDL_Display, getme, XA_STRING, atom_sel, SDL_Window,
CurrentTime);
/* at some point in the near future, we'll get a SelectionNotify
see _x11_clip_filter for more details;
because of this (otherwise) oddity, we take the selection immediately...
*/
unlock_display();
return NULL;
}
#else
if (cb == CLIPPY_BUFFER) {
#if defined(WIN32)
if (IsClipboardFormatAvailable(CF_TEXT) && OpenClipboard(SDL_Window)) {
_hmem = GetClipboardData(CF_TEXT);
if (_hmem) {
if (_current_selection != _current_clipboard) {
free(_current_clipboard);
}
_current_clipboard = NULL;
src = (char*)GlobalLock(_hmem);
if (src) {
clen = GlobalSize(_hmem);
if (clen > 0) {
_current_clipboard = mem_alloc(clen+1);
memcpy(_current_clipboard, src, clen);
_current_clipboard[clen] = '\0';
}
GlobalUnlock(_hmem);
}
}
CloseClipboard();
_hmem = NULL;
}
#elif defined(__QNXNTO__)
if (_current_selection != _current_clipboard) {
free(_current_clipboard);
}
_current_clipboard = NULL;
#if (NTO_VERSION < 620)
clhandle = PhClipboardPasteStart(inputgroup);
if (clhandle) {
clheader = PhClipboardPasteType(clhandle,
Ph_CLIPBOARD_TYPE_TEXT);
if (clheader) {
cldata = clheader->data;
if (clheader->length > 4 && *cldata == Ph_CL_TEXT) {
src = ((char *)clheader->data)+4;
clen = clheader->length - 4;
_current_clipboard = mem_alloc(clen+1);
memcpy(_current_clipboard, src, clen);
_current_clipboard[clen] = '\0';
}
PhClipboardPasteFinish(clhandle);
}
}
#else
/* argh! qnx */
clheader = PhClipboardRead(inputgroup, Ph_CLIPBOARD_TYPE_TEXT);
if (clheader) {
cldata = clheader->data;
if (clheader->length > 4 && *cldata == Ph_CL_TEXT) {
src = ((char *)clheader->data)+4;
clen = clheader->length - 4;
_current_clipboard = mem_alloc(clen+1);
memcpy(_current_clipboard, src, clen);
_current_clipboard[clen] = '\0';
}
}
#endif /* NTO version selector */
/* okay, we either own the buffer, or it's a selection for folks without */
#endif /* win32/qnx */
}
#endif /* x11/others */
/* fall through; the current window owns it */
}
if (cb == CLIPPY_SELECT) return _current_selection;
#ifdef MACOSX
if (cb == CLIPPY_BUFFER) {
src = str_dup(macosx_clippy_get());
if (_current_clipboard != _current_selection) {
free(_current_clipboard);
}
_current_clipboard = src;
if (!src) return (char *) ""; /* FIXME: de-const-ing is bad */
return _current_clipboard;
}
#else
if (cb == CLIPPY_BUFFER) return _current_clipboard;
#endif
return NULL;
}
static int _x11_clip_filter(const SDL_Event *ev)
{
XSelectionRequestEvent *req;
XEvent sevent;
Atom seln_type;
int seln_format;
unsigned long nbytes;
unsigned long overflow;
unsigned char *seln_data;
unsigned char *src;
if (ev->type != SDL_SYSWMEVENT) return 1;
if (ev->syswm.msg->event.xevent.type == SelectionNotify) {
sevent = ev->syswm.msg->event.xevent;
if (sevent.xselection.requestor == SDL_Window) {
lock_display();
src = NULL;
if (XGetWindowProperty(SDL_Display, SDL_Window, atom_sel,
0, 9000, False, XA_STRING,
(Atom *)&seln_type,
(int *)&seln_format,
(unsigned long *)&nbytes,
(unsigned long *)&overflow,
(unsigned char **)&src) == Success) {
if (seln_type == XA_STRING) {
if (_current_selection != _current_clipboard) {
free(_current_clipboard);
}
_current_clipboard = mem_alloc(nbytes+1);
memcpy(_current_clipboard, (char*)src, nbytes);
_current_clipboard[nbytes] = 0;
_string_paste(CLIPPY_BUFFER, _current_clipboard);
_widget_owner[CLIPPY_BUFFER]
= _widget_owner[CLIPPY_SELECT];
}
XFree(src);
}
unlock_display();
}
return 1;
} else if (ev->syswm.msg->event.xevent.type == PropertyNotify) {
sevent = ev->syswm.msg->event.xevent;
return 1;
} else if (ev->syswm.msg->event.xevent.type != SelectionRequest) {
return 1;
}
req = &ev->syswm.msg->event.xevent.xselectionrequest;
sevent.xselection.type = SelectionNotify;
sevent.xselection.display = req->display;
sevent.xselection.selection = req->selection;
sevent.xselection.target = None;
sevent.xselection.property = None;
sevent.xselection.requestor = req->requestor;
sevent.xselection.time = req->time;
if (XGetWindowProperty(SDL_Display, DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER0, 0, 9000, False, req->target,
&sevent.xselection.target, &seln_format,
&nbytes, &overflow, &seln_data) == Success) {
if (sevent.xselection.target == req->target) {
if (sevent.xselection.target == XA_STRING) {
if (nbytes && seln_data[nbytes-1] == '\0')
nbytes--;
}
XChangeProperty(SDL_Display, req->requestor, req->property,
sevent.xselection.target, seln_format, PropModeReplace,
seln_data, nbytes);
sevent.xselection.property = req->property;
}
XFree(seln_data);
}
XSendEvent(SDL_Display,req->requestor,False,0,&sevent);
XSync(SDL_Display, False);
return 1;
}
