builtin/modmgr.lua

   1 --Minetest
   2 --Copyright (C) 2013 sapier
   3 --
   4 --This program is free software; you can redistribute it and/or modify
   5 --it under the terms of the GNU Lesser General Public License as published by
   6 --the Free Software Foundation; either version 2.1 of the License, or
   7 --(at your option) any later version.
   8 --
   9 --This program is distributed in the hope that it will be useful,
  10 --but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 --MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 --GNU Lesser General Public License for more details.
  13 --
  14 --You should have received a copy of the GNU Lesser General Public License along
  15 --with this program; if not, write to the Free Software Foundation, Inc.,
  16 --51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17
  18 --------------------------------------------------------------------------------
  19 function get_mods(path,retval,modpack)
  20
  21         local mods = engine.get_dirlist(path,true)
  22         for i=1,#mods,1 do
  23                 local toadd = {}
  24                 local modpackfile = nil
  25
  26                 toadd.name              = mods[i]
  27                 toadd.path              = path .. DIR_DELIM .. mods[i] .. DIR_DELIM
  28                 if modpack ~= nil and
  29                         modpack ~= "" then
  30                         toadd.modpack   = modpack
  31                 else
  32                         local filename = path .. DIR_DELIM .. mods[i] .. DIR_DELIM .. "modpack.txt"
  33                         local error = nil
  34                         modpackfile,error = io.open(filename,"r")
  35                 end
  36
  37                 if modpackfile ~= nil then
  38                         modpackfile:close()
  39                         toadd.is_modpack = true
  40                         table.insert(retval,toadd)
  41                         get_mods(path .. DIR_DELIM .. mods[i],retval,mods[i])
  42                 else
  43                         table.insert(retval,toadd)
  44                 end
  45         end
  46 end
  47
  48 --modmanager implementation
  49 modmgr = {}
  50
  51 --------------------------------------------------------------------------------
  52 function modmgr.extract(modfile)
  53         if modfile.type == "zip" then
  54                 local tempfolder = os.tempfolder()
  55
  56                 if tempfolder ~= nil and
  57                         tempfodler ~= "" then
  58                         engine.create_dir(tempfolder)
  59                         engine.extract_zip(modfile.name,tempfolder)
  60                         return tempfolder
  61                 end
  62         end
  63 end
  64
  65 -------------------------------------------------------------------------------
  66 function modmgr.getbasefolder(temppath)
  67
  68         if temppath == nil then
  69                 return {
  70                 type = "invalid",
  71                 path = ""
  72                 }
  73         end
  74
  75         local testfile = io.open(temppath .. DIR_DELIM .. "init.lua","r")
  76         if testfile ~= nil then
  77                 testfile:close()
  78                 return {
  79                                 type="mod",
  80                                 path=temppath
  81                                 }
  82         end
  83
  84         testfile = io.open(temppath .. DIR_DELIM .. "modpack.txt","r")
  85         if testfile ~= nil then
  86                 testfile:close()
  87                 return {
  88                                 type="modpack",
  89                                 path=temppath
  90                                 }
  91         end
  92
  93         local subdirs = engine.get_dirlist(temppath,true)
  94
  95         --only single mod or modpack allowed
  96         if #subdirs ~= 1 then
  97                 return {
  98                         type = "invalid",
  99                         path = ""
 100                         }
 101         end
 102
 103         testfile =
 104         io.open(temppath .. DIR_DELIM .. subdirs[1] ..DIR_DELIM .."init.lua","r")
 105         if testfile ~= nil then
 106                 testfile:close()
 107                 return {
 108                         type="mod",
 109                         path= temppath .. DIR_DELIM .. subdirs[1]
 110                         }
 111         end
 112
 113         testfile =
 114         io.open(temppath .. DIR_DELIM .. subdirs[1] ..DIR_DELIM .."modpack.txt","r")
 115         if testfile ~= nil then
 116                 testfile:close()
 117                 return {
 118                         type="modpack",
 119                         path=temppath ..  DIR_DELIM .. subdirs[1]
 120                         }
 121         end
 122
 123         return {
 124                 type = "invalid",
 125                 path = ""
 126                 }
 127 end
 128
 129 --------------------------------------------------------------------------------
 130 function modmgr.isValidModname(modpath)
 131         if modpath:find("-") ~= nil then
 132                 return false
 133         end
 134
 135         return true
 136 end
 137
 138 --------------------------------------------------------------------------------
 139 function modmgr.parse_register_line(line)
 140         local pos1 = line:find("\"")
 141         local pos2 = nil
 142         if pos1 ~= nil then
 143                 pos2 = line:find("\"",pos1+1)
 144         end
 145
 146         if pos1 ~= nil and pos2 ~= nil then
 147                 local item = line:sub(pos1+1,pos2-1)
 148
 149                 if item ~= nil and
 150                         item ~= "" then
 151                         local pos3 = item:find(":")
 152
 153                         if pos3 ~= nil then
 154                                 local retval = item:sub(1,pos3-1)
 155                                 if retval ~= nil and
 156                                         retval ~= "" then
 157                                         return retval
 158                                 end
 159                         end
 160                 end
 161         end
 162         return nil
 163 end
 164
 165 --------------------------------------------------------------------------------
 166 function modmgr.parse_dofile_line(modpath,line)
 167         local pos1 = line:find("\"")
 168         local pos2 = nil
 169         if pos1 ~= nil then
 170                 pos2 = line:find("\"",pos1+1)
 171         end
 172
 173         if pos1 ~= nil and pos2 ~= nil then
 174                 local filename = line:sub(pos1+1,pos2-1)
 175
 176                 if filename ~= nil and
 177                         filename ~= "" and
 178                         filename:find(".lua") then
 179                         return modmgr.identify_modname(modpath,filename)
 180                 end
 181         end
 182         return nil
 183 end
 184
 185 --------------------------------------------------------------------------------
 186 function modmgr.identify_modname(modpath,filename)
 187         local testfile = io.open(modpath .. DIR_DELIM .. filename,"r")
 188         if testfile ~= nil then
 189                 local line = testfile:read()
 190
 191                 while line~= nil do
 192                         local modname = nil
 193
 194                         if line:find("minetest.register_tool") then
 195                                 modname = modmgr.parse_register_line(line)
 196                         end
 197
 198                         if line:find("minetest.register_craftitem") then
 199                                 modname = modmgr.parse_register_line(line)
 200                         end
 201
 202
 203                         if line:find("minetest.register_node") then
 204                                 modname = modmgr.parse_register_line(line)
 205                         end
 206
 207                         if line:find("dofile") then
 208                                 modname = modmgr.parse_dofile_line(modpath,line)
 209                         end
 210
 211                         if modname ~= nil then
 212                                 testfile:close()
 213                                 return modname
 214                         end
 215
 216                         line = testfile:read()
 217                 end
 218                 testfile:close()
 219         end
 220
 221         return nil
 222 end
 223
 224 --------------------------------------------------------------------------------
 225 function modmgr.tab()
 226
 227         if modmgr.global_mods == nil then
 228                 modmgr.refresh_globals()
 229         end
 230
 231         if modmgr.selected_mod == nil then
 232                 modmgr.selected_mod = 1
 233         end
 234
 235         local retval =
 236                 "vertlabel[0,-0.25;MODS]" ..
 237                 "label[0.8,-0.25;Installed Mods:]" ..
 238                 "textlist[0.75,0.25;4.5,4.3;modlist;" ..
 239                 modmgr.render_modlist(modmgr.global_mods) ..
 240                 ";" .. modmgr.selected_mod .. "]"
 241
 242         retval = retval ..
 243                 "button[1,4.85;2,0.5;btn_mod_mgr_install_local;Install]" ..
 244                 "button[3,4.85;2,0.5;btn_mod_mgr_download;Download]"
 245
 246         local selected_mod = nil
 247
 248         if filterlist.size(modmgr.global_mods) >= modmgr.selected_mod then
 249                 selected_mod = filterlist.get_list(modmgr.global_mods)[modmgr.selected_mod]
 250         end
 251
 252         if selected_mod ~= nil then
 253                 if selected_mod.is_modpack then
 254                         retval = retval .. "button[10,4.85;2,0.5;btn_mod_mgr_rename_modpack;Rename]"
 255                 else
 256                 --show dependencies
 257                         retval = retval ..
 258                                 "label[6,1.9;Depends:]" ..
 259                                 "textlist[6,2.4;5.7,2;deplist;"
 260
 261                         toadd = modmgr.get_dependencies(selected_mod.path)
 262
 263                         retval = retval .. toadd .. ";0;true,false]"
 264
 265                         --TODO read modinfo
 266                 end
 267                 --show delete button
 268                 retval = retval .. "button[8,4.85;2,0.5;btn_mod_mgr_delete_mod;Delete]"
 269         end
 270         return retval
 271 end
 272
 273 --------------------------------------------------------------------------------
 274 function modmgr.dialog_rename_modpack()
 275
 276         local mod = filterlist.get_list(modmgr.modlist)[modmgr.selected_mod]
 277
 278         local retval =
 279                 "label[1.75,1;Rename Modpack:]"..
 280                 "field[4.5,1.4;6,0.5;te_modpack_name;;" ..
 281                 mod.name ..
 282                 "]" ..
 283                 "button[5,4.2;2.6,0.5;dlg_rename_modpack_confirm;Accept]" ..
 284                 "button[7.5,4.2;2.8,0.5;dlg_rename_modpack_cancel;Cancel]"
 285
 286         return retval
 287 end
 288
 289 --------------------------------------------------------------------------------
 290 function modmgr.precheck()
 291
 292         if modmgr.world_config_selected_world == nil then
 293                 modmgr.world_config_selected_world = 1
 294         end
 295
 296         if modmgr.world_config_selected_mod == nil then
 297                 modmgr.world_config_selected_mod = 1
 298         end
 299
 300         if modmgr.hide_gamemods == nil then
 301                 modmgr.hide_gamemods = true
 302         end
 303
 304         if modmgr.hide_modpackcontents == nil then
 305                 modmgr.hide_modpackcontents = true
 306         end
 307 end
 308
 309 --------------------------------------------------------------------------------
 310 function modmgr.render_modlist(render_list)
 311         local retval = ""
 312
 313         if render_list == nil then
 314                 if modmgr.global_mods == nil then
 315                         modmgr.refresh_globals()
 316                 end
 317                 render_list = modmgr.global_mods
 318         end
 319
 320         local list = filterlist.get_list(render_list)
 321         local last_modpack = nil
 322
 323         for i,v in ipairs(list) do
 324                 if retval ~= "" then
 325                         retval = retval ..","
 326                 end
 327
 328                 if v.is_modpack then
 329                         local rawlist = filterlist.get_raw_list(render_list)
 330
 331                         local all_enabled = true
 332                         for j=1,#rawlist,1 do
 333                                 if rawlist[j].modpack == list[i].name and
 334                                         rawlist[j].enabled ~= true then
 335                                                 all_enabled = false
 336                                                 break
 337                                 end
 338                         end
 339
 340                         if all_enabled == false then
 341                                 retval = retval .. mt_color_grey
 342                         else
 343                                 retval = retval .. mt_color_dark_green
 344                         end
 345                 end
 346
 347                 if v.typ == "game_mod" then
 348                         retval = retval .. mt_color_blue
 349                 else
 350                         if v.enabled then
 351                                 retval = retval .. mt_color_green
 352                         end
 353                 end
 354                 if v.modpack  ~= nil then
 355                         retval = retval .. "    "
 356                 end
 357                 retval = retval .. v.name
 358         end
 359
 360         return retval
 361 end
 362
 363 --------------------------------------------------------------------------------
 364 function modmgr.dialog_configure_world()
 365         modmgr.precheck()
 366
 367         local worldspec = engine.get_worlds()[modmgr.world_config_selected_world]
 368         local mod = filterlist.get_list(modmgr.modlist)[modmgr.world_config_selected_mod]
 369
 370         local retval =
 371                 "size[11,6.5]" ..
 372                 "label[1.5,-0.25;World: " .. worldspec.name .. "]"
 373
 374         if modmgr.hide_gamemods then
 375                 retval = retval .. "checkbox[0,5.75;cb_hide_gamemods;Hide Game;true]"
 376         else
 377                 retval = retval .. "checkbox[0,5.75;cb_hide_gamemods;Hide Game;false]"
 378         end
 379
 380         if modmgr.hide_modpackcontents then
 381                 retval = retval .. "checkbox[2,5.75;cb_hide_mpcontent;Hide mp content;true]"
 382         else
 383                 retval = retval .. "checkbox[2,5.75;cb_hide_mpcontent;Hide mp content;false]"
 384         end
 385
 386         if mod == nil then
 387                 mod = {name=""}
 388         end
 389         retval = retval ..
 390                 "label[0,0.45;Mod:]" ..
 391                 "label[0.75,0.45;" .. mod.name .. "]" ..
 392                 "label[0,1;Depends:]" ..
 393                 "textlist[0,1.5;5,4.25;world_config_depends;" ..
 394                 modmgr.get_dependencies(mod.path) .. ";0]" ..
 395                 "button[9.25,6.35;2,0.5;btn_config_world_save;Save]" ..
 396                 "button[7.4,6.35;2,0.5;btn_config_world_cancel;Cancel]"
 397
 398         if engine.setting_get("old_style_mod_selection") == "true" then
 399                 if mod ~= nil and mod.name ~= "" then
 400                         if mod.is_modpack then
 401                                 local rawlist = filterlist.get_raw_list(modmgr.modlist)
 402
 403                                 local all_enabled = true
 404                                 for j=1,#rawlist,1 do
 405                                         if rawlist[j].modpack == mod.name and
 406                                                 rawlist[j].enabled ~= true then
 407                                                         all_enabled = false
 408                                                         break
 409                                         end
 410                                 end
 411
 412                                 if all_enabled == false then
 413                                         retval = retval .. "button[5.5,-0.125;2,0.5;btn_mp_enable;Enable MP]"
 414                                 else
 415                                         retval = retval .. "button[5.5,-0.125;2,0.5;btn_mp_disable;Disable MP]"
 416                                 end
 417                         else
 418                                 if mod.enabled then
 419                                         retval = retval .. "checkbox[5.5,-0.375;cb_mod_enable;enabled;true]"
 420                                 else
 421                                         retval = retval .. "checkbox[5.5,-0.375;cb_mod_enable;enabled;false]"
 422                                 end
 423                         end
 424
 425                 end
 426
 427                 retval = retval ..
 428                         "button[8.5,-0.125;2.5,0.5;btn_all_mods;Enable all]"
 429         else
 430                 retval = retval ..
 431                 "button[5.5,-0.125;5.75,0.5;btn_all_mods;Enable all Mods]"
 432         end
 433                 retval = retval ..
 434                 "textlist[5.5,0.5;5.5,5.75;world_config_modlist;"
 435
 436
 437         retval = retval .. modmgr.render_modlist(modmgr.modlist)
 438
 439         retval = retval .. ";" .. modmgr.world_config_selected_mod .."]"
 440
 441         return retval
 442 end
 443
 444 --------------------------------------------------------------------------------
 445 function modmgr.handle_buttons(tab,fields)
 446
 447         local retval = nil
 448
 449         if tab == "mod_mgr" then
 450                 retval = modmgr.handle_modmgr_buttons(fields)
 451         end
 452
 453         if tab == "dialog_rename_modpack" then
 454                 retval = modmgr.handle_rename_modpack_buttons(fields)
 455         end
 456
 457         if tab == "dialog_delete_mod" then
 458                 retval = modmgr.handle_delete_mod_buttons(fields)
 459         end
 460
 461         if tab == "dialog_configure_world" then
 462                 retval = modmgr.handle_configure_world_buttons(fields)
 463         end
 464
 465         return retval
 466 end
 467
 468 --------------------------------------------------------------------------------
 469 function modmgr.get_dependencies(modfolder)
 470         local toadd = ""
 471         if modfolder ~= nil then
 472                 local filename = modfolder ..
 473                                         DIR_DELIM .. "depends.txt"
 474
 475                 local dependencyfile = io.open(filename,"r")
 476
 477                 if dependencyfile then
 478                         local dependency = dependencyfile:read("*l")
 479                         while dependency do
 480                                 if toadd ~= "" then
 481                                         toadd = toadd .. ","
 482                                 end
 483                                 toadd = toadd .. dependency
 484                                 dependency = dependencyfile:read()
 485                         end
 486                         dependencyfile:close()
 487                 end
 488         end
 489
 490         return toadd
 491 end
 492
 493
 494 --------------------------------------------------------------------------------
 495 function modmgr.get_worldconfig(worldpath)
 496         local filename = worldpath ..
 497                                 DIR_DELIM .. "world.mt"
 498
 499         local worldfile = io.open(filename,"r")
 500
 501         local worldconfig = {}
 502         worldconfig.global_mods = {}
 503         worldconfig.game_mods = {}
 504
 505         if worldfile then
 506                 local dependency = worldfile:read("*l")
 507                 while dependency do
 508                         local parts = dependency:split("=")
 509
 510                         local key = parts[1]:trim()
 511
 512                         if key == "gameid" then
 513                                 worldconfig.id = parts[2]:trim()
 514                         else
 515                                 local key = parts[1]:trim():sub(10)
 516                                 if parts[2]:trim() == "true" then
 517                                         worldconfig.global_mods[key] = true
 518                                 else
 519                                         worldconfig.global_mods[key] = false
 520                                 end
 521                         end
 522                         dependency = worldfile:read("*l")
 523                 end
 524                 worldfile:close()
 525         else
 526                 print("Modmgr: " .. filename .. " not found")
 527         end
 528
 529         --read gamemods
 530         local gamemodpath = engine.get_gamepath() .. DIR_DELIM .. worldconfig.id .. DIR_DELIM .. "mods"
 531
 532         get_mods(gamemodpath,worldconfig.game_mods)
 533
 534         return worldconfig
 535 end
 536 --------------------------------------------------------------------------------
 537 function modmgr.handle_modmgr_buttons(fields)
 538         local retval = {
 539                         tab = nil,
 540                         is_dialog = nil,
 541                         show_buttons = nil,
 542                 }
 543
 544         if fields["modlist"] ~= nil then
 545                 local event = explode_textlist_event(fields["modlist"])
 546                 modmgr.selected_mod = event.index
 547         end
 548
 549         if fields["btn_mod_mgr_install_local"] ~= nil then
 550                 engine.show_file_open_dialog("mod_mgt_open_dlg","Select Mod File:")
 551         end
 552
 553         if fields["btn_mod_mgr_download"] ~= nil then
 554                 retval.current_tab = "dialog_modstore_unsorted"
 555                 retval.is_dialog = true
 556                 retval.show_buttons = false
 557                 return retval
 558         end
 559
 560         if fields["btn_mod_mgr_rename_modpack"] ~= nil then
 561                 retval.current_tab = "dialog_rename_modpack"
 562                 retval.is_dialog = true
 563                 retval.show_buttons = false
 564                 return retval
 565         end
 566
 567         if fields["btn_mod_mgr_delete_mod"] ~= nil then
 568                 retval.current_tab = "dialog_delete_mod"
 569                 retval.is_dialog = true
 570                 retval.show_buttons = false
 571                 return retval
 572         end
 573
 574         if fields["mod_mgt_open_dlg_accepted"] ~= nil and
 575                 fields["mod_mgt_open_dlg_accepted"] ~= "" then
 576                 modmgr.installmod(fields["mod_mgt_open_dlg_accepted"],nil)
 577         end
 578
 579         return nil;
 580 end
 581
 582 --------------------------------------------------------------------------------
 583 function modmgr.installmod(modfilename,basename)
 584         local modfile = modmgr.identify_filetype(modfilename)
 585         local modpath = modmgr.extract(modfile)
 586
 587         if modpath == nil then
 588                 gamedata.errormessage = "Install Mod: file: " .. modfile.name ..
 589                         "\nInstall Mod: unsupported filetype \"" .. modfile.type .. "\""
 590                 return
 591         end
 592
 593
 594         local basefolder = modmgr.getbasefolder(modpath)
 595
 596         if basefolder.type == "modpack" then
 597                 local clean_path = nil
 598
 599                 if basename ~= nil then
 600                         clean_path = "mp_" .. basename
 601                 end
 602
 603                 if clean_path == nil then
 604                         clean_path = get_last_folder(cleanup_path(basefolder.path))
 605                 end
 606
 607                 if clean_path ~= nil then
 608                         local targetpath = engine.get_modpath() .. DIR_DELIM .. clean_path
 609                         if not engine.copy_dir(basefolder.path,targetpath) then
 610                                 gamedata.errormessage = "Failed to install " .. basename .. " to " .. targetpath
 611                         end
 612                 else
 613                         gamedata.errormessage = "Install Mod: unable to find suitable foldername for modpack "
 614                                 .. modfilename
 615                 end
 616         end
 617
 618         if basefolder.type == "mod" then
 619                 local targetfolder = basename
 620
 621                 if targetfolder == nil then
 622                         targetfolder = modmgr.identify_modname(basefolder.path,"init.lua")
 623                 end
 624
 625                 --if heuristic failed try to use current foldername
 626                 if targetfolder == nil then
 627                         targetfolder = get_last_folder(basefolder.path)
 628                 end
 629
 630                 if targetfolder ~= nil and modmgr.isValidModname(targetfolder) then
 631                         local targetpath = engine.get_modpath() .. DIR_DELIM .. targetfolder
 632                         engine.copy_dir(basefolder.path,targetpath)
 633                 else
 634                         gamedata.errormessage = "Install Mod: unable to find real modname for: "
 635                                 .. modfilename
 636                 end
 637         end
 638
 639         engine.delete_dir(modpath)
 640
 641         modmgr.refresh_globals()
 642
 643 end
 644
 645 --------------------------------------------------------------------------------
 646 function modmgr.handle_rename_modpack_buttons(fields)
 647
 648         if fields["dlg_rename_modpack_confirm"] ~= nil then
 649                 local mod = filterlist.get_list(modmgr.modlist)[modmgr.selected_mod]
 650                 local oldpath = engine.get_modpath() .. DIR_DELIM .. mod.name
 651                 local targetpath = engine.get_modpath() .. DIR_DELIM .. fields["te_modpack_name"]
 652                 engine.copy_dir(oldpath,targetpath,false)
 653         end
 654
 655         return {
 656                 is_dialog = false,
 657                 show_buttons = true,
 658                 current_tab = engine.setting_get("main_menu_tab")
 659                 }
 660 end
 661 --------------------------------------------------------------------------------
 662 function modmgr.handle_configure_world_buttons(fields)
 663         if fields["world_config_modlist"] ~= nil then
 664                 local event = explode_textlist_event(fields["world_config_modlist"])
 665                 modmgr.world_config_selected_mod = event.index
 666
 667                 if engine.setting_get("old_style_mod_selection") ~= "true" then
 668                         if event.typ == "DCL" then
 669                                 local mod = filterlist.get_list(modmgr.modlist)[event.index]
 670
 671                                 if mod.typ == "game_mod" then
 672                                         return nil
 673                                 end
 674
 675                                 if not mod.is_modpack then
 676                                         mod.enabled = not mod.enabled
 677                                 else
 678                                         local list = filterlist.get_raw_list(modmgr.modlist)
 679                                         local toset = nil
 680
 681                                         for i=1,#list,1 do
 682                                                 if list[i].modpack == mod.name then
 683                                                         if toset == nil then
 684                                                                 toset = not list[i].enabled
 685                                                         end
 686
 687                                                         list[i].enabled = toset
 688                                                 end
 689                                         end
 690                                 end
 691                         end
 692                 end
 693         end
 694
 695         if engine.setting_get("old_style_mod_selection") == "true" then
 696                 if fields["cb_mod_enable"] ~= nil then
 697                         local mod = filterlist.get_list(modmgr.modlist)
 698                                 [engine.get_textlist_index("world_config_modlist")]
 699                         if fields["cb_mod_enable"] == "true" then
 700                                 mod.enabled = true
 701                         else
 702                                 mod.enabled = false
 703                         end
 704                 end
 705
 706                 if fields["btn_mp_enable"] ~= nil or
 707                         fields["btn_mp_disable"] then
 708                         local mod = filterlist.get_list(modmgr.modlist)
 709                                 [engine.get_textlist_index("world_config_modlist")]
 710
 711                         local toset=false
 712                         if fields["btn_mp_enable"] ~= nil then
 713                                 toset = true
 714                         end
 715                         local list = filterlist.get_raw_list(modmgr.modlist)
 716
 717                         for i=1,#list,1 do
 718                                 if list[i].modpack == mod.name then
 719                                         list[i].enabled = toset
 720                                 end
 721                         end
 722                 end
 723         end
 724
 725         if fields["cb_hide_gamemods"] ~= nil then
 726                 local current = filterlist.get_filtercriteria(modmgr.modlist)
 727
 728                 if current == nil then
 729                         current = {}
 730                 end
 731
 732                 if fields["cb_hide_gamemods"] == "true" then
 733                         current.hide_game = true
 734                         modmgr.hide_gamemods = true
 735                 else
 736                         current.hide_game = false
 737                         modmgr.hide_gamemods = false
 738                 end
 739
 740                 filterlist.set_filtercriteria(modmgr.modlist,current)
 741         end
 742
 743                 if fields["cb_hide_mpcontent"] ~= nil then
 744                 local current = filterlist.get_filtercriteria(modmgr.modlist)
 745
 746                 if current == nil then
 747                         current = {}
 748                 end
 749
 750                 if fields["cb_hide_mpcontent"] == "true" then
 751                         current.hide_modpackcontents = true
 752                         modmgr.hide_modpackcontents = true
 753                 else
 754                         current.hide_modpackcontents = false
 755                         modmgr.hide_modpackcontents = false
 756                 end
 757
 758                 filterlist.set_filtercriteria(modmgr.modlist,current)
 759         end
 760
 761         if fields["btn_config_world_save"] then
 762                 local worldspec = engine.get_worlds()[modmgr.world_config_selected_world]
 763
 764                 local filename = worldspec.path ..
 765                                 DIR_DELIM .. "world.mt"
 766
 767                 local worldfile = io.open(filename,"w")
 768
 769                 if worldfile then
 770                         worldfile:write("gameid = " .. modmgr.worldconfig.id .. "\n")
 771
 772                         local rawlist = filterlist.get_raw_list(modmgr.modlist)
 773
 774                         for i=1,#rawlist,1 do
 775
 776                                 if not rawlist[i].is_modpack and
 777                                         rawlist[i].typ ~= "game_mod" then
 778                                         if rawlist[i].enabled then
 779                                                 worldfile:write("load_mod_" .. rawlist[i].name .. " = true" .. "\n")
 780                                         else
 781                                                 worldfile:write("load_mod_" .. rawlist[i].name .. " = false" .. "\n")
 782                                         end
 783                                 end
 784                         end
 785
 786                         worldfile:close()
 787                 else
 788                         print("failed to open world config file")
 789                 end
 790
 791                 modmgr.modlist = nil
 792                 modmgr.worldconfig = nil
 793
 794                 return {
 795                         is_dialog = false,
 796                         show_buttons = true,
 797                         current_tab = engine.setting_get("main_menu_tab")
 798                 }
 799         end
 800
 801         if fields["btn_config_world_cancel"] then
 802
 803                 modmgr.worldconfig = nil
 804
 805                 return {
 806                         is_dialog = false,
 807                         show_buttons = true,
 808                         current_tab = engine.setting_get("main_menu_tab")
 809                 }
 810         end
 811
 812         if fields["btn_all_mods"] then
 813                 local list = filterlist.get_raw_list(modmgr.modlist)
 814
 815                 for i=1,#list,1 do
 816                         if list[i].typ ~= "game_mod" and
 817                                 not list[i].is_modpack then
 818                                 list[i].enabled = true
 819                         end
 820                 end
 821         end
 822
 823
 824
 825         return nil
 826 end
 827 --------------------------------------------------------------------------------
 828 function modmgr.handle_delete_mod_buttons(fields)
 829         local mod = filterlist.get_list(modmgr.global_mods)[modmgr.selected_mod]
 830
 831         if fields["dlg_delete_mod_confirm"] ~= nil then
 832
 833                 if mod.path ~= nil and
 834                         mod.path ~= "" and
 835                         mod.path ~= engine.get_modpath() then
 836                         if not engine.delete_dir(mod.path) then
 837                                 gamedata.errormessage ="Modmgr: failed to delete >" .. mod.path .. "<"
 838                         end
 839                         modmgr.refresh_globals()
 840                 else
 841                         gamedata.errormessage ="Modmgr: invalid modpath >" .. mod.path .. "<"
 842                 end
 843         end
 844
 845         return {
 846                 is_dialog = false,
 847                 show_buttons = true,
 848                 current_tab = engine.setting_get("main_menu_tab")
 849                 }
 850 end
 851
 852 --------------------------------------------------------------------------------
 853 function modmgr.dialog_delete_mod()
 854
 855         local mod = filterlist.get_list(modmgr.global_mods)[modmgr.selected_mod]
 856
 857         local retval =
 858                 "field[1.75,1;10,3;;Are you sure you want to delete ".. mod.name .. "?;]"..
 859                 "button[4,4.2;1,0.5;dlg_delete_mod_confirm;Yes]" ..
 860                 "button[6.5,4.2;3,0.5;dlg_delete_mod_cancel;No of course not!]"
 861
 862         return retval
 863 end
 864
 865 --------------------------------------------------------------------------------
 866 function modmgr.preparemodlist(data)
 867         local retval = {}
 868
 869         local global_mods = {}
 870         local game_mods = {}
 871
 872         --read global mods
 873         local modpath = engine.get_modpath()
 874
 875         if modpath ~= nil and
 876                 modpath ~= "" then
 877                 get_mods(modpath,global_mods)
 878         end
 879
 880         for i=1,#global_mods,1 do
 881                 global_mods[i].typ = "global_mod"
 882                 table.insert(retval,global_mods[i])
 883         end
 884
 885         --read game mods
 886         if data.gameid ~= nil and
 887                 data.gameid ~= "" then
 888                 local gamemodpath = engine.get_gamepath() .. DIR_DELIM .. data.gameid .. DIR_DELIM .. "mods"
 889
 890                 get_mods(gamemodpath,game_mods)
 891         end
 892
 893         for i=1,#game_mods,1 do
 894                 game_mods[i].typ = "game_mod"
 895                 table.insert(retval,game_mods[i])
 896         end
 897
 898         if data.worldpath == nil then
 899                 return retval
 900         end
 901
 902         --read world mod configuration
 903         local filename = data.worldpath ..
 904                                 DIR_DELIM .. "world.mt"
 905
 906         local worldfile = io.open(filename,"r")
 907         if worldfile then
 908                 local dependency = worldfile:read("*l")
 909                 while dependency do
 910                         local parts = dependency:split("=")
 911
 912                         local key = parts[1]:trim()
 913
 914                         if key ~= "gameid" then
 915                                 local key = parts[1]:trim():sub(10)
 916                                 local element = nil
 917                                 for i=1,#retval,1 do
 918                                         if retval[i].name == key then
 919                                                 element = retval[i]
 920                                                 break
 921                                         end
 922                                 end
 923                                 if element ~= nil then
 924                                         if parts[2]:trim() == "true" then
 925                                                 element.enabled = true
 926                                         else
 927                                                 element.enabled = false
 928                                         end
 929                                 else
 930                                         print("Mod: " .. key .. " " .. dump(parts[2]) .. " but not found")
 931                                 end
 932                         end
 933                         dependency = worldfile:read("*l")
 934                 end
 935                 worldfile:close()
 936
 937         end
 938
 939         return retval
 940 end
 941
 942 --------------------------------------------------------------------------------
 943 function modmgr.init_worldconfig()
 944         modmgr.precheck()
 945         local worldspec = engine.get_worlds()[modmgr.world_config_selected_world]
 946
 947         if worldspec ~= nil then
 948                 --read worldconfig
 949                 modmgr.worldconfig = modmgr.get_worldconfig(worldspec.path)
 950
 951                 if modmgr.worldconfig.id == nil or
 952                         modmgr.worldconfig.id == "" then
 953                         modmgr.worldconfig = nil
 954                         return false
 955                 end
 956
 957                 modmgr.modlist = filterlist.create(
 958                                                 modmgr.preparemodlist, --refresh
 959                                                 modmgr.comparemod, --compare
 960                                                 function(element,uid) --uid match
 961                                                         if element.name == uid then
 962                                                                 return true
 963                                                         end
 964                                                 end,
 965                                                 function(element,criteria)
 966                                                         if criteria.hide_game and
 967                                                                 element.typ == "game_mod" then
 968                                                                         return false
 969                                                         end
 970
 971                                                         if criteria.hide_modpackcontents and
 972                                                                 element.modpack ~= nil then
 973                                                                         return false
 974                                                                 end
 975                                                         return true
 976                                                 end, --filter
 977                                                 { worldpath= worldspec.path,
 978                                                   gameid = worldspec.gameid }
 979                                         )
 980
 981                 filterlist.set_filtercriteria(modmgr.modlist, {
 982                                                                         hide_game=modmgr.hide_gamemods,
 983                                                                         hide_modpackcontents= modmgr.hide_modpackcontents
 984                                                                         })
 985
 986                 return true
 987         end
 988
 989         return false
 990 end
 991
 992 --------------------------------------------------------------------------------
 993 function modmgr.comparemod(elem1,elem2)
 994         if elem1 == nil or elem2 == nil then
 995                 return false
 996         end
 997         if elem1.name ~= elem2.name then
 998                 return false
 999         end
1000         if elem1.is_modpack ~= elem2.is_modpack then
1001                 return false
1002         end
1003         if elem1.typ ~= elem2.typ then
1004                 return false
1005         end
1006         if elem1.modpack ~= elem2.modpack then
1007                 return false
1008         end
1009
1010         if elem1.path ~= elem2.path then
1011                 return false
1012         end
1013
1014         return true
1015 end
1016
1017 --------------------------------------------------------------------------------
1018 function modmgr.gettab(name)
1019         local retval = ""
1020
1021         if name == "mod_mgr" then
1022                 retval = retval .. modmgr.tab()
1023         end
1024
1025         if name == "dialog_rename_modpack" then
1026                 retval = retval .. modmgr.dialog_rename_modpack()
1027         end
1028
1029         if name == "dialog_delete_mod" then
1030                 retval = retval .. modmgr.dialog_delete_mod()
1031         end
1032
1033         if name == "dialog_configure_world" then
1034                 retval = retval .. modmgr.dialog_configure_world()
1035         end
1036
1037         return retval
1038 end
1039
1040 --------------------------------------------------------------------------------
1041 function modmgr.mod_exists(basename)
1042
1043         if modmgr.global_mods == nil then
1044                 modmgr.refresh_globals()
1045         end
1046
1047         if filterlist.raw_index_by_uid(modmgr.global_mods,basename) > 0 then
1048                 return true
1049         end
1050
1051         return false
1052 end
1053
1054 --------------------------------------------------------------------------------
1055 function modmgr.get_global_mod(idx)
1056
1057         if modmgr.global_mods == nil then
1058                 return nil
1059         end
1060
1061         if idx < 1 or idx > filterlist.size(modmgr.global_mods) then
1062                 return nil
1063         end
1064
1065         return filterlist.get_list(modmgr.global_mods)[idx]
1066 end
1067
1068 --------------------------------------------------------------------------------
1069 function modmgr.refresh_globals()
1070         modmgr.global_mods = filterlist.create(
1071                                         modmgr.preparemodlist, --refresh
1072                                         modmgr.comparemod, --compare
1073                                         function(element,uid) --uid match
1074                                                 if element.name == uid then
1075                                                         return true
1076                                                 end
1077                                         end,
1078                                         nil, --filter
1079                                         {}
1080                                         )
1081 end
1082
1083 --------------------------------------------------------------------------------
1084 function modmgr.identify_filetype(name)
1085
1086         if name:sub(-3):lower() == "zip" then
1087                 return {
1088                                 name = name,
1089                                 type = "zip"
1090                                 }
1091         end
1092
1093         if name:sub(-6):lower() == "tar.gz" or
1094                 name:sub(-3):lower() == "tgz"then
1095                 return {
1096                                 name = name,
1097                                 type = "tgz"
1098                                 }
1099         end
1100
1101         if name:sub(-6):lower() == "tar.bz2" then
1102                 return {
1103                                 name = name,
1104                                 type = "tbz"
1105                                 }
1106         end
1107
1108         if name:sub(-2):lower() == "7z" then
1109                 return {
1110                                 name = name,
1111                                 type = "7z"
1112                                 }
1113         end
1114
1115         return {
1116                 name = name,
1117                 type = "ukn"
1118         }
1119 end