static void main_window_load(Window *window) {
// Here we load the bitmap assets
/*
s_menu_icons[0] = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_MENU_ICON_BIG_WATCH);
s_menu_icons[1] = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_MENU_ICON_SECTOR_WATCH);
s_menu_icons[2] = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_MENU_ICON_BINARY_WATCH);
*/
// And also load the background
//s_background_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BACKGROUND_BRAINS);
//init list of books:
int i;
for (i=0; i<NUM_FIRST_MENU_ITEMS; i++){
snprintf(book_list[i].name, sizeof(book_list[i].name), "Book %d", i+1);
}
//if data was saved, read it:
load_items();
// Now we prepare to initialize the menu layer
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_frame(window_layer);
// Create the menu layer
s_menu_layer = menu_layer_create(bounds);
menu_layer_set_callbacks(s_menu_layer, NULL, (MenuLayerCallbacks){
.get_num_sections = menu_get_num_sections_callback,
.get_num_rows = menu_get_num_rows_callback,
.get_header_height = menu_get_header_height_callback,
.draw_header = menu_draw_header_callback,
.draw_row = menu_draw_row_callback,
.select_click = menu_select_callback,
});
void
gltk_spinner_set_selected_index(GltkSpinner* spinner, int level, int index)
{
g_return_if_fail(GLTK_IS_SPINNER(spinner));
USING_PRIVATE(spinner);
g_return_if_fail(level >= 0 && level < priv->model->levels);
int len = g_list_length(priv->wheels[level].items);
if (!len)
return;
g_return_if_fail(index >= 0 && index < len);
set_selected_index(spinner, level, index);
priv->wheels[level].index = index;
if (level == priv->model->levels - 1)
{
g_object_ref(spinner);
g_signal_emit(spinner, signals[ITEM_SELECTED], 0);
g_object_unref(spinner);
}
else
{
load_items(spinner, level+1, gltk_spinner_model_get_items(priv->model, level, index));
}
}
void Floor::load(InputStream *stream, int notebook_version, NaturalLanguage language) {
if (stream->get() != FLOOR_MARKER) {
say_error(IDS_BAD_FLOOR_IN_CITY_FILE,TRUE);
return;
};
Sprites *floor_items = load_items(stream,notebook_version,language);
if (floor_items != NULL) {
// add_items(floor_items);
Sprites *remaining = floor_items;
while (remaining != NULL) {
// new on 101099 if priority of item is fixed then don't reset it
// so Marty, for example, loads in with correct priority
add_item(remaining->first(),FALSE);
// FALSE replaced !remaining->first()->priority_fixed() above on 211199 since priority is now saved correctly
remaining = remaining->rest();
};
floor_items->recursively_propagate_changes();
floor_items->activate();
floor_items->remove_all();
delete floor_items;
};
if (notebook_version >= first_version_to_save_number_colors) {
stream->read((string) ¤t_priority, sizeof(current_priority)); // new on 150100
};
};
void
gltk_spinner_reload_base_items(GltkSpinner* spinner)
{
g_return_if_fail(GLTK_IS_SPINNER(spinner));
USING_PRIVATE(spinner);
//load our toplevel items from the model
load_items(spinner, 0, gltk_spinner_model_clone_items(priv->model, priv->model->toplevel));
}
static void
gltk_spinner_set_property(GObject* object, guint property_id, const GValue* value, GParamSpec* pspec)
{
GltkSpinner* self = GLTK_SPINNER(object);
USING_PRIVATE(self);
switch (property_id)
{
case PROP_MODEL:
{
GltkSpinnerModel* model = GLTK_SPINNER_MODEL(g_value_get_object(value));
priv->hbox = gltk_hbox_new(1);
g_object_ref(model);
priv->model = model;
//initialize the wheels
priv->wheels = g_new(Wheel, priv->model->levels);
int i;
for (i = 0; i < priv->model->levels; i++)
{
Wheel* wheel = priv->wheels + i;
wheel->vbox = gltk_vbox_new(0);
wheel->scrollable = gltk_scrollable_new();
g_object_ref(wheel->vbox);
g_object_ref(wheel->scrollable);
gltk_scrollable_set_widget(GLTK_SCROLLABLE(wheel->scrollable), wheel->vbox);
gltk_box_append_widget(GLTK_BOX(priv->hbox), wheel->scrollable, TRUE, TRUE);
g_signal_connect(wheel->scrollable, "touch-event", (GCallback)scrollable_touch_event, self);
wheel->items = NULL;
wheel->index = 0;
}
//load our toplevel items from the model
load_items(self, 0, gltk_spinner_model_clone_items(priv->model, priv->model->toplevel));
gltk_bin_set_widget(GLTK_BIN(self), priv->hbox);
}
break;
case PROP_VISIBLE_ITEMS:
{
priv->visibleItems = g_value_get_int(value);
int i;
for (i = 0; i < priv->model->levels; i++)
set_padding(self, &priv->wheels[i]);
gltk_widget_layout(GLTK_WIDGET(object));
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
}
}
static gboolean
idle_handle_recent_changed (gpointer data)
{
CinnamonDocSystem *self = CINNAMON_DOC_SYSTEM (data);
self->priv->idle_recent_changed_id = 0;
g_slist_free_full (self->priv->infos_by_timestamp, (GDestroyNotify) gtk_recent_info_unref);
load_items(self);
g_signal_emit (self, signals[CHANGED], 0);
return FALSE;
}
static void
cinnamon_doc_system_init (CinnamonDocSystem *self)
{
CinnamonDocSystemPrivate *priv;
self->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
CINNAMON_TYPE_DOC_SYSTEM,
CinnamonDocSystemPrivate);
self->priv->manager = gtk_recent_manager_get_default ();
load_items(self);
g_signal_connect (self->priv->manager, "changed", G_CALLBACK(cinnamon_doc_system_on_recent_changed), self);
}
int main(){
BYTE i=0;
char euro[10];
load_items();
load_state();
for (i=0; i < status.num_items; ++i) {
cprintf("%x: %s (%s, %d mal)\n",
i, status.status[i].item_name, format_euro(euro, 9, status.status[i].price),
status.status[i].times_sold);
status.status[i].times_sold += 10;
}
save_state();
load_items();
load_state();
for (i=0; i < status.num_items; ++i) {
cprintf("%x: %s (%s, %d mal)\n",
i, status.status[i].item_name, format_euro(euro, 9, status.status[i].price),
status.status[i].times_sold);
}
cprintf("strlen(%s)==%d\n", status.status[1].item_name, strlen(status.status[1].item_name));
cprintf("%d %d %d\n", status.status[1].item_name[0], '\r', '\n');
}
static gboolean
scrollable_touch_event(GltkWidget* scrollable, GltkEventTouch* event, GltkSpinner* spinner)
{
USING_PRIVATE(spinner);
if (event->touchType == TOUCH_END)
{
int level;
for (level = 0; level < priv->model->levels; level++)
{
if (priv->wheels[level].scrollable != scrollable)
continue;
int index = get_selected_index(spinner, level);
GLTK_SCROLLABLE(priv->wheels[level].scrollable)->offset.y = (-index + priv->visibleItems/2) * priv->itemHeight;
if (index != priv->wheels[level].index)
{
priv->wheels[level].index = index;
if (level == priv->model->levels - 1)
{
g_object_ref(spinner);
g_signal_emit(spinner, signals[ITEM_SELECTED], 0);
g_object_unref(spinner);
}
else
{
//load our new items into the next spinner
load_items(spinner, level+1, gltk_spinner_model_get_items(priv->model, level, index));
gltk_widget_layout(GLTK_WIDGET(spinner));
}
}
break;
}
}
return FALSE;
}
void Room::load(InputStream *stream, int notebook_version, NaturalLanguage language) {
if (stream->get() != ROOM_MARKER) {
log(S(IDS_BAD_ROOM_IN_CITY_FILE),FALSE,TRUE);
return;
};
Sprite *saved_wall_decoration = load_item(stream,notebook_version,language);
if (saved_wall_decoration != NULL) {
saved_wall_decoration->recursively_propagate_changes(); // new on 160601 to get offsets right
set_wall_decoration_sprite(saved_wall_decoration);
// Sprites *remaining = saved_wall_decoration->pointer_to_followers();
// while (remaining != NULL) {
// Sprite *sprite = remaining->first();
// position_and_add_to_wall(Sprite *wall_remote, Sprite *addition, Room *room)
};
Sprites *floor_items = load_items(stream,notebook_version,language);
if (floor_items != NULL) {
add_items(floor_items);
floor_items->recursively_propagate_changes();
floor_items->activate();
floor_items->remove_all();
delete floor_items;
};
};
int main(int argc, char* argv[])
{
START_LOG;
init_text_drawing();
config::load_config();
// Load databases.
load_spells();
load_items();
load_monsters();
load_classes();
load_status_effects();
srand(time(0));
SceneManager::instance().create();
if (argc > 1)
{
std::string arg = argv[1];
if (arg == "test")
{
start_test_battle();
return 0;
}
}
// SceneManager::instance().addScene(&Game::instance());
SceneManager::instance().addScene(new TitleScreen);
SceneManager::instance().run();
return 0;
}
LJEntry*
draft_store_ui_select(DraftStore *ds, GtkWindow *parent) {
DraftStoreUI dsui_actual = {0}, *dsui = &dsui_actual;
LJEntry *entry = NULL;
dsui->ds = ds;
dsui->store = gtk_list_store_new(COL_COUNT,
/*GDK_TYPE_PIXBUF, */G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
make_dialog(dsui, parent);
/*dsui->pb_friends = gtk_widget_render_icon(dsui->win,
"logjam-protected", GTK_ICON_SIZE_MENU, NULL);
dsui->pb_private = gtk_widget_render_icon(dsui->win,
"logjam-private", GTK_ICON_SIZE_MENU, NULL);*/
if (!load_items(dsui))
return NULL;
if (gtk_dialog_run(GTK_DIALOG(dsui->win)) == GTK_RESPONSE_OK)
entry = load_selected(dsui);
gtk_widget_destroy(dsui->win);
return entry;
}
static void
load_items(GltkSpinner* spinner, int level, GList* items)
{
USING_PRIVATE(spinner);
Wheel* wheel = priv->wheels + level;
//clean up an old mess
if (wheel->items)
{
gltk_spinner_model_free_items(priv->model, wheel->items);
g_object_unref(wheel->vbox);
wheel->vbox = gltk_vbox_new(0);
g_object_ref(wheel->vbox);
gltk_scrollable_set_widget(GLTK_SCROLLABLE(wheel->scrollable), wheel->vbox);
}
//make a new one
wheel->items = items;
int itemHeight = priv->itemHeight;
GList* pItems = wheel->items;
while (pItems)
{
GltkSpinnerModelItem* item = (GltkSpinnerModelItem*)pItems->data;
GltkWidget* label = gltk_label_new(item->text);
GLTK_LABEL(label)->color.r = 0.0f;
GLTK_LABEL(label)->color.g = 0.0f;
GLTK_LABEL(label)->color.b = 0.0f;
gltk_box_append_widget(GLTK_BOX(wheel->vbox), label, FALSE, FALSE);
GltkSize size;
gltk_widget_size_request(label, &size);
if (size.height > itemHeight)
itemHeight = size.height;
size.width = -1;
size.height = priv->itemHeight;
gltk_widget_set_size_request(label, size);
pItems = pItems->next;
}
//if our max height changed, relayout and resize
if (itemHeight > priv->itemHeight)
{
priv->itemHeight = itemHeight;
priv->heightChanged = TRUE;
gltk_widget_layout(GLTK_WIDGET(spinner));
}
//select a specific item
int len = g_list_length(wheel->items);
if (wheel->index >= len - 1)
wheel->index = len-1;
if (wheel->index < 0)
wheel->index = 0;
set_selected_index(spinner, level, wheel->index);
//set allowable amount to scroll past the vbox
set_padding(spinner, wheel);
//either signal that an item was selected or recurse until we do
if (level == priv->model->levels-1)
{
g_object_ref(spinner);
g_signal_emit(spinner, signals[ITEM_SELECTED], 0);
g_object_unref(spinner);
}
else
{
load_items(spinner, level+1, gltk_spinner_model_get_items(priv->model, level, wheel->index));
}
}
int load_map(char *filename)
{
FILE *f;
void *temp;
int sect,i;
long size,r;
char nmapend=1;
static char las=1;
static char newcode=0;
passpass=0;
purge_mob_map();
if (las)
{
if (check_sound_map())
msg_box("Upozorn�n�!",'\x1',"Verze souboru SOUND.DAT neodpovid� verz�m ostatn�ch soubor�. To m��e zp�sobit poru�en� integrity ukazatel� na zvukov� soubory!","Pokra�ovat",NULL);
load_all_shops();
las=0;
}
load_mobs();
load_sound_map();
load_items();
password[0]=0;
f=fopen(filename,"rb");
if (f==NULL) return 0;
do
{
r=load_section(f,&temp,§,&size);
if (r==size)
switch (sect)
{
case A_SIDEMAP:
memcpy(&mapa.sidedef,temp,size);
break;
case A_SECTMAP:
memcpy(&mapa.sectordef,temp,size);
break;
case A_MAPGLOB:
memset(&mglob,0,sizeof(mglob));
if (size>sizeof(mglob)) size=sizeof(mglob);
memcpy(&mglob,temp,size);
/* if (size>sizeof(mglob)-sizeof(mglob.mappassw))
{
decrypt2(mglob.mappassw,password);
passpass=2;
if (password[0]) newcode=1;
}*/
break;
case A_MAPINFO:
memcpy(&minfo,temp,size);
maplen=size / sizeof(TMAP_EDIT_INFO);
sect=0;
for (i=0;i<maplen;i++) sect+=minfo[i].layer;
if (sect/maplen<-20) Shift_map_sectors_up();
if (sect/maplen>20) Shift_map_sectors_down();
break;
case A_MAPMACR:
load_macros(temp);
break;
case A_MAPEND:
nmapend=0;
break;
case A_MAPITEM:
load_item_map(temp,size);
break;
case A_MAPMOBS:
load_mob_map(temp,size);
break;
case A_MOBS:
load_mobs_to_map(temp,size);
mglob.local_monsters=1;
break;
case A_MOBSND:
load_sound_dat(temp,size);
break;
case A_MAPVYK:
memcpy(vyklenky,temp,size);
break;
case A_PASSW:
/* if (passpass<2)
{
memcpy(password,temp,size);
encrypt(password);
passpass=2;
}*/
break;
}
else
{
if (temp!=NULL)free(temp);
fclose(f);
return -1;
}
free(temp);
}
while (nmapend);
fclose(f);
for(r=1;r<maplen;r++)
for(i=0;i<4;i++)
if (mapa.sidedef[r][i].flags & 0x40000)
if ((minfo[r].x+minfo[r].y+i)& 1) mapa.sidedef[r][i].prim-=(mapa.sidedef[r][i].prim_anim & 0xf)+1;
backup=0;
if (newcode) Shift_map_sectors_down();
return 0;
}
