int display_wood(void)
{
m_hide();
v_box(3,0,190,40,198,140);
v_box(3,2,190,40,198,40+men.wood*10);
m_show();
}
void ConferenceWindow::SetEmoticonLayout(QVBoxLayout *layout)
{
//qDebug()<<"set lay";
if(!m_emoticonsv_button || m_emo_layout) return;
switch(m_emomode)
{
case 0: m_emoticonsv_button->hide(); m_emoticons_button->show(); return; break;
case 1: m_emoticonsv_button->show(); m_emoticons_button->hide(); break;
case 2: m_emoticonsv_button->show(); m_emoticons_button->show(); break;
}
//************* Emoticons Layer Bottom ***************
m_emo_layout = new QHBoxLayout();
layout->addLayout(m_emo_layout);
if(!v_emoticon_widget)
{
v_emoticon_widget = new ChatEmoticonBar(this);
v_emoticon_widget->setEmoticons(GetEmoticonsH());
v_emoticon_widget->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
v_emoticon_widget->ensureGeometry();
v_emoticon_widget->setAutoclose(m_emoautoclose,m_emoclosetime);
connect(v_emoticon_widget, SIGNAL(m_hide()), this,
SLOT(setEmoBtnStat()));
v_emoticon_widget->hide();
m_emo_layout->addWidget(v_emoticon_widget);
connect(v_emoticon_widget, SIGNAL(insertSmile(const QString &)), this,
SLOT(insertEmoticon(const QString &)));
}
int cond_hide( int x, int y )
{
int mx = m_xpos();
int my = m_ypos();
if( (abs(x-mx) + abs(y-my)) < 30 )
{
m_hide();
}
}
int displayall(void)
{
int x ,y ,m, grebles=0, home=0;
m_hide();
v_box( 15, 0, 49, 49, 150, 170 );
for(x=0; x<DIM_X/*60*/; x++)
{
for(y=0; y<DIM_Y/*30*/; y++)
{
m = x * DIM_Y/*30*/ + y;
if(map[m].tera > 0)
{
v_box( 1, 0, 50+y*2, 50+x*2, 51+y*2, 51+x*2 );
}
if(map[m].greble > 0 & map[m].greble!=COLONIST/*6*/)
{
v_box( 2, 0, 50+y*2, 50+x*2, 51+y*2, 51+x*2 );
grebles++;
}
if(map[m].greble==COLONIST/*6*/)
{
v_box( 3, 0, 50+y*2, 50+x*2, 51+y*2, 51+x*2 );
home++;
}
}
}
v_box( 4, 0, 50+men.y*2, 50+men.x*2, 51+men.y*2, 51+men.x*2 );
v_cprintf( 36, 0, 60, 115, 1, 0, "%i Grebles", grebles );
v_cprintf( 36, 0, 60, 135, 1, 0, "%i Homes", home );
bioskey(0);
m_show();
if(grebles==0)
{
return(1);
}
else
{
return(0);
}
}
static bool reissue_connection(struct config_info *conf, struct host **h, char *host_name)
{
bool ret = false;
int buf_len;
assert(h != NULL);
/* We might be passed an existing socket. If we have been, close
* and destroy the associated host, and create a new one.
*/
if(*h)
host_destroy(*h);
*h = host_create(HOST_TYPE_TCP, HOST_FAMILY_IPV4);
if(!*h)
{
error("Failed to create TCP client socket.", 1, 8, 0);
goto err_out;
}
m_hide();
buf_len = snprintf(widget_buf, WIDGET_BUF_LEN,
"Connecting to \"%s\". Please wait..", host_name);
widget_buf[WIDGET_BUF_LEN - 1] = 0;
draw_window_box(3, 11, 76, 13, DI_MAIN, DI_DARK, DI_CORNER, 1, 1);
write_string(widget_buf, (WIDGET_BUF_LEN - buf_len) >> 1, 12, DI_TEXT, 0);
update_screen();
if(!host_connect(*h, host_name, OUTBOUND_PORT))
{
buf_len = snprintf(widget_buf, WIDGET_BUF_LEN,
"Connection to \"%s\" failed.", host_name);
widget_buf[WIDGET_BUF_LEN - 1] = 0;
error(widget_buf, 1, 8, 0);
}
else
ret = true;
clear_screen(32, 7);
m_show();
update_screen();
err_out:
return ret;
}
int main(int argc, char *argv[])
{
initial();
if (!strcmp (argv[1], "-r"))
load_game (argv[2]);
gameloop();
v_reset_mode();
m_hide();
m_close();
save_game (GAMEFILE);
}
int error(const char *string, unsigned int type, unsigned int options,
unsigned int code)
{
const char *type_name;
int t1 = 9, ret = 0;
char temp[5];
int x;
// Find the name of this error type.
if(type >= sizeof(error_type_names) / sizeof(*error_type_names))
type = 0;
type_name = error_type_names[type];
// If graphics couldn't initialize, print the error to stderr and abort.
if(!has_video_initialized())
{
fprintf(stderr, "%s%s\n", type_name, string);
exit(-1);
}
// Window
set_context(code >> 8);
m_hide();
save_screen();
dialog_fadein();
draw_window_box(1, 10, 78, 14, 76, 64, 72, 1, 1);
// Add title and error name
x = 40 - (int)strlen(type_name)/2;
write_string(type_name, x, 10, 78, 0);
write_string(string, 40 - ((Uint32)strlen(string) / 2), 11, 79, 0);
// Add options
write_string("Press", 4, 13, 78, 0);
if(options & ERROR_OPT_FAIL)
{
write_string(", F for Fail", t1, 13, 78, 0);
t1 += 12;
}
if(options & ERROR_OPT_RETRY)
{
write_string(", R to Retry", t1, 13, 78, 0);
t1 += 12;
}
if(options & ERROR_OPT_EXIT)
{
write_string(", E to Exit", t1, 13, 78, 0);
t1 += 11;
}
if(options & ERROR_OPT_OK)
{
write_string(", O for OK", t1, 13, 78, 0);
t1 += 10;
}
draw_char('.', 78, t1, 13);
draw_char(':', 78, 9, 13);
// Add code if not 0
if(code != 0)
{
write_string(" Debug code:0000h ", 30, 14, 64, 0);
sprintf(temp, "%x", code);
write_string(temp, 46 - (Uint32)strlen(temp), 14, 64, 0);
}
update_screen();
// Get key
do
{
wait_event();
t1 = get_key(keycode_internal);
//Process
switch(t1)
{
case IKEY_f:
fail:
if(!(options & ERROR_OPT_FAIL)) break;
ret = ERROR_OPT_FAIL;
break;
case IKEY_r:
retry:
if(!(options & ERROR_OPT_RETRY)) break;
ret = ERROR_OPT_RETRY;
break;
case IKEY_e:
exit:
if(!(options & ERROR_OPT_EXIT)) break;
ret = ERROR_OPT_EXIT;
break;
case IKEY_o:
ok:
if(!(options & ERROR_OPT_OK)) break;
ret = ERROR_OPT_OK;
break;
case IKEY_h:
if(!(options & ERROR_OPT_HELP)) break;
// Call help
break;
case IKEY_ESCAPE:
// Escape. Order of options this applies to-
// Fail, Ok, Retry, Exit.
if(options & ERROR_OPT_FAIL ) goto fail;
if(options & ERROR_OPT_OK ) goto ok;
if(options & ERROR_OPT_RETRY) goto retry;
goto exit;
case IKEY_RETURN:
// Enter. Order of options this applies to-
// OK, Retry, Fail, Exit.
if(options & ERROR_OPT_OK ) goto ok;
if(options & ERROR_OPT_RETRY) goto retry;
if(options & ERROR_OPT_FAIL ) goto fail;
goto exit;
}
} while(ret == 0);
pop_context();
// Restore screen and exit appropriately
dialog_fadeout();
restore_screen();
m_show();
if(ret == ERROR_OPT_EXIT) // Exit the program
{
platform_quit();
exit(-1);
}
return ret;
}
static void __check_for_updates(struct world *mzx_world, struct config_info *conf)
{
int cur_host;
char *update_host;
bool try_next_host = true;
bool ret = false;
set_context(CTX_UPDATER);
if(conf->update_host_count < 1)
{
error("No updater hosts defined! Aborting.", 1, 8, 0);
goto err_out;
}
if(!swivel_current_dir(true))
goto err_out;
for(cur_host = 0; (cur_host < conf->update_host_count) && try_next_host; cur_host++)
{
char **list_entries, buffer[LINE_BUF_LEN], *url_base, *value;
struct manifest_entry *removed, *replaced, *added, *e;
int i = 0, entries = 0, buf_len, result;
char update_branch[LINE_BUF_LEN];
const char *version = VERSION;
int list_entry_width = 0;
enum host_status status;
struct host *h = NULL;
unsigned int retries;
FILE *f;
// Acid test: Can we write to this directory?
f = fopen_unsafe(UPDATES_TXT, "w+b");
if(!f)
{
error("Failed to create \"" UPDATES_TXT "\". Check permissions.", 1, 8, 0);
goto err_chdir;
}
update_host = conf->update_hosts[cur_host];
if(!reissue_connection(conf, &h, update_host))
goto err_host_destroy;
for(retries = 0; retries < MAX_RETRIES; retries++)
{
// Grab the file containing the names of the current Stable and Unstable
status = host_recv_file(h, "/" UPDATES_TXT, f, "text/plain");
rewind(f);
if(status == HOST_SUCCESS)
break;
if(!reissue_connection(conf, &h, update_host))
goto err_host_destroy;
}
if(retries == MAX_RETRIES)
{
snprintf(widget_buf, WIDGET_BUF_LEN, "Failed to download \""
UPDATES_TXT "\" (err=%d).\n", status);
widget_buf[WIDGET_BUF_LEN - 1] = 0;
error(widget_buf, 1, 8, 0);
goto err_host_destroy;
}
snprintf(update_branch, LINE_BUF_LEN, "Current-%s",
conf->update_branch_pin);
// Walk this list (of two, hopefully)
while(true)
{
char *m = buffer, *key;
value = NULL;
// Grab a single line from the manifest
if(!fgets(buffer, LINE_BUF_LEN, f))
break;
key = strsep(&m, ":\n");
if(!key)
break;
value = strsep(&m, ":\n");
if(!value)
break;
if(strcmp(key, update_branch) == 0)
break;
}
fclose(f);
unlink(UPDATES_TXT);
/* There was no "Current-XXX: Version" found; we cannot proceed with the
* update because we cannot compute an update URL below.
*/
if(!value)
{
error("Failed to identify applicable update version.", 1, 8, 0);
goto err_host_destroy;
}
/* There's likely to be a space prepended to the version number.
* Skip it here.
*/
if(value[0] == ' ')
value++;
/* We found the latest update version, but we should check to see if that
* matches the version we're already using. The user may choose to receive
* "stability" updates for their current major version, or upgrade to the
* newest one.
*/
if(strcmp(value, version) != 0)
{
struct element *elements[6];
struct dialog di;
buf_len = snprintf(widget_buf, WIDGET_BUF_LEN,
"A new major version is available (%s)", value);
widget_buf[WIDGET_BUF_LEN - 1] = 0;
elements[0] = construct_label((55 - buf_len) >> 1, 2, widget_buf);
elements[1] = construct_label(2, 4,
"You can continue to receive updates for the version\n"
"installed (if available), or you can upgrade to the\n"
"newest major version (recommended).");
elements[2] = construct_label(2, 8,
"If you do not upgrade, this question will be asked\n"
"again the next time you run the updater.\n");
elements[3] = construct_button(9, 11, "Upgrade", 0);
elements[4] = construct_button(21, 11, "Update Old", 1);
elements[5] = construct_button(36, 11, "Cancel", 2);
construct_dialog(&di, "New Major Version", 11, 6, 55, 14, elements, 6, 3);
result = run_dialog(mzx_world, &di);
destruct_dialog(&di);
// User pressed Escape, abort all updates
if(result < 0 || result == 2)
{
try_next_host = false;
goto err_host_destroy;
}
// User pressed Upgrade, use new major
if(result == 0)
version = value;
}
/* We can now compute a unique URL base for the updater. This will
* be composed of a user-selected version and a static platform-archicture
* name.
*/
url_base = cmalloc(LINE_BUF_LEN);
snprintf(url_base, LINE_BUF_LEN, "/%s/" PLATFORM, version);
debug("Update base URL: %s\n", url_base);
/* The call to manifest_get_updates() destroys any existing manifest
* file in this directory. Since we still allow user to abort after
* this call, and downloading the updates may fail, we copy the
* old manifest to a backup location and optionally restore it later.
*/
if(!backup_original_manifest())
{
error("Failed to back up manifest. Check permissions.", 1, 8, 0);
try_next_host = false;
goto err_free_url_base;
}
for(retries = 0; retries < MAX_RETRIES; retries++)
{
bool m_ret;
m_hide();
draw_window_box(3, 11, 76, 13, DI_MAIN, DI_DARK, DI_CORNER, 1, 1);
write_string("Computing manifest deltas (added, replaced, deleted)..",
13, 12, DI_TEXT, 0);
update_screen();
m_ret = manifest_get_updates(h, url_base, &removed, &replaced, &added);
clear_screen(32, 7);
m_show();
update_screen();
if(m_ret)
break;
if(!reissue_connection(conf, &h, update_host))
goto err_roll_back_manifest;
}
if(retries == MAX_RETRIES)
{
error("Failed to compute update manifests", 1, 8, 0);
goto err_roll_back_manifest;
}
// At this point, we have a successful manifest, so we won't need another host
try_next_host = false;
if(!removed && !replaced && !added)
{
struct element *elements[3];
struct dialog di;
elements[0] = construct_label(2, 2, "This client is already current.");
elements[1] = construct_button(7, 4, "OK", 0);
elements[2] = construct_button(13, 4, "Try next host", 1);
construct_dialog(&di, "No Updates", 22, 9, 35, 6, elements, 3, 1);
result = run_dialog(mzx_world, &di);
destruct_dialog(&di);
if((result == 1) && (cur_host < conf->update_host_count))
try_next_host = true;
goto err_free_update_manifests;
}
for(e = removed; e; e = e->next, entries++)
list_entry_width = MAX(list_entry_width, 2 + (int)strlen(e->name)+1+1);
for(e = replaced; e; e = e->next, entries++)
list_entry_width = MAX(list_entry_width, 2 + (int)strlen(e->name)+1+1);
for(e = added; e; e = e->next, entries++)
list_entry_width = MAX(list_entry_width, 2 + (int)strlen(e->name)+1+1);
// We don't want the listbox to be too wide
list_entry_width = MIN(list_entry_width, 60);
list_entries = cmalloc(entries * sizeof(char *));
for(e = removed; e; e = e->next, i++)
{
list_entries[i] = cmalloc(list_entry_width);
snprintf(list_entries[i], list_entry_width, "- %s", e->name);
list_entries[i][list_entry_width - 1] = 0;
}
for(e = replaced; e; e = e->next, i++)
{
list_entries[i] = cmalloc(list_entry_width);
snprintf(list_entries[i], list_entry_width, "* %s", e->name);
list_entries[i][list_entry_width - 1] = 0;
}
for(e = added; e; e = e->next, i++)
{
list_entries[i] = cmalloc(list_entry_width);
snprintf(list_entries[i], list_entry_width, "+ %s", e->name);
list_entries[i][list_entry_width - 1] = 0;
}
draw_window_box(19, 1, 59, 4, DI_MAIN, DI_DARK, DI_CORNER, 1, 1);
write_string(" Task Summary ", 33, 1, DI_TITLE, 0);
write_string("ESC - Cancel [+] Add [-] Delete", 21, 2, DI_TEXT, 0);
write_string("ENTER - Proceed [*] Replace ", 21, 3, DI_TEXT, 0);
result = list_menu((const char **)list_entries, list_entry_width,
NULL, 0, entries, ((80 - (list_entry_width + 9)) >> 1) + 1, 4);
for(i = 0; i < entries; i++)
free(list_entries[i]);
free(list_entries);
clear_screen(32, 7);
update_screen();
if(result < 0)
goto err_free_update_manifests;
/* Defer deletions until we restart; any of these files may still be
* in use by this (old) process. Reduce the number of entries by the
* number of removed items for the progress meter below.
*/
for(e = removed; e; e = e->next, entries--)
delete_hook(e->name);
/* Since the operations for adding and replacing a file are identical,
* we modify the replaced list and tack on the added list to the end.
*
* Either list may be NULL; in the case that `replaced' is NULL, simply
* re-assign the `added' pointer. `added' being NULL has no effect.
*
* Later, we need only free the replaced list (see below).
*/
if(replaced)
{
for(e = replaced; e->next; e = e->next)
;
e->next = added;
}
else
replaced = added;
cancel_update = false;
host_set_callbacks(h, NULL, recv_cb, cancel_cb);
i = 1;
for(e = replaced; e; e = e->next, i++)
{
for(retries = 0; retries < MAX_RETRIES; retries++)
{
char name[72];
bool m_ret;
if(!check_create_basedir(e->name))
goto err_free_delete_list;
final_size = (long)e->size;
m_hide();
snprintf(name, 72, "%s (%ldb) [%u/%u]", e->name, final_size, i, entries);
meter(name, 0, final_size);
update_screen();
m_ret = manifest_entry_download_replace(h, url_base, e, delete_hook);
clear_screen(32, 7);
m_show();
update_screen();
if(m_ret)
break;
if(cancel_update)
{
error("Download was cancelled; update aborted.", 1, 8, 0);
goto err_free_delete_list;
}
if(!reissue_connection(conf, &h, update_host))
goto err_free_delete_list;
host_set_callbacks(h, NULL, recv_cb, cancel_cb);
}
if(retries == MAX_RETRIES)
{
snprintf(widget_buf, WIDGET_BUF_LEN,
"Failed to download \"%s\" (after %d attempts).", e->name, retries);
widget_buf[WIDGET_BUF_LEN - 1] = 0;
error(widget_buf, 1, 8, 0);
goto err_free_delete_list;
}
}
if(delete_list)
{
f = fopen_unsafe(DELETE_TXT, "wb");
if(!f)
{
error("Failed to create \"" DELETE_TXT "\". Check permissions.", 1, 8, 0);
goto err_free_delete_list;
}
for(e = delete_list; e; e = e->next)
{
fprintf(f, "%08x%08x%08x%08x%08x%08x%08x%08x %lu %s\n",
e->sha256[0], e->sha256[1], e->sha256[2], e->sha256[3],
e->sha256[4], e->sha256[5], e->sha256[6], e->sha256[7],
e->size, e->name);
}
fclose(f);
}
try_next_host = false;
ret = true;
err_free_delete_list:
manifest_list_free(&delete_list);
delete_list = delete_p = NULL;
err_free_update_manifests:
manifest_list_free(&removed);
manifest_list_free(&replaced);
err_roll_back_manifest:
restore_original_manifest(ret);
err_free_url_base:
free(url_base);
err_host_destroy:
host_destroy(h);
pop_context();
} //end host for loop
err_chdir:
swivel_current_dir_back(true);
err_out:
/* At this point we found updates and we successfully updated
* to them. Reload the program with the original argv.
*/
if(ret)
{
const void *argv = process_argv;
struct element *elements[2];
struct dialog di;
elements[0] = construct_label(2, 2,
"This client will now attempt to restart itself.");
elements[1] = construct_button(23, 4, "OK", 0);
construct_dialog(&di, "Update Successful", 14, 9, 51, 6, elements, 2, 1);
run_dialog(mzx_world, &di);
destruct_dialog(&di);
execv(process_argv[0], argv);
perror("execv");
error("Attempt to invoke self failed!", 1, 8, 0);
return;
}
}