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                 local selected = engine.get_textlist_index("world_config_modlist")
 400                 local mod = filterlist.get_list(modmgr.modlist)[selected]
 401
 402                 if mod ~= nil then
 403                         if mod.is_modpack then
 404                                 local rawlist = filterlist.get_raw_list(modmgr.modlist)
 405
 406                                 local all_enabled = true
 407                                 for j=1,#rawlist,1 do
 408                                         if rawlist[j].modpack == mod.name and
 409                                                 rawlist[j].enabled ~= true then
 410                                                         all_enabled = false
 411                                                         break
 412                                         end
 413                                 end
 414
 415                                 if all_enabled == false then
 416                                         retval = retval .. "button[5.5,-0.125;2,0.5;btn_mp_enable;Enable MP]"
 417                                 else
 418                                         retval = retval .. "button[5.5,-0.125;2,0.5;btn_mp_disable;Disable MP]"
 419                                 end
 420                         else
 421                                 if mod.enabled then
 422                                         retval = retval .. "checkbox[5.5,-0.375;cb_mod_enable;enabled;true]"
 423                                 else
 424                                         retval = retval .. "checkbox[5.5,-0.375;cb_mod_enable;enabled;false]"
 425                                 end
 426                         end
 427
 428                 end
 429
 430                 retval = retval ..
 431                         "button[8.5,-0.125;2.5,0.5;btn_all_mods;Enable all]"
 432         else
 433                 retval = retval ..
 434                 "button[5.5,-0.125;5.75,0.5;btn_all_mods;Enable all Mods]"
 435         end
 436                 retval = retval ..
 437                 "textlist[5.5,0.5;5.5,5.75;world_config_modlist;"
 438
 439
 440         retval = retval .. modmgr.render_modlist(modmgr.modlist)
 441
 442         retval = retval .. ";" .. modmgr.world_config_selected_mod .."]"
 443
 444         return retval
 445 end
 446
 447 --------------------------------------------------------------------------------
 448 function modmgr.handle_buttons(tab,fields)
 449
 450         local retval = nil
 451
 452         if tab == "mod_mgr" then
 453                 retval = modmgr.handle_modmgr_buttons(fields)
 454         end
 455
 456         if tab == "dialog_rename_modpack" then
 457                 retval = modmgr.handle_rename_modpack_buttons(fields)
 458         end
 459
 460         if tab == "dialog_delete_mod" then
 461                 retval = modmgr.handle_delete_mod_buttons(fields)
 462         end
 463
 464         if tab == "dialog_configure_world" then
 465                 retval = modmgr.handle_configure_world_buttons(fields)
 466         end
 467
 468         return retval
 469 end
 470
 471 --------------------------------------------------------------------------------
 472 function modmgr.get_dependencies(modfolder)
 473         local toadd = ""
 474         if modfolder ~= nil then
 475                 local filename = modfolder ..
 476                                         DIR_DELIM .. "depends.txt"
 477
 478                 local dependencyfile = io.open(filename,"r")
 479
 480                 if dependencyfile then
 481                         local dependency = dependencyfile:read("*l")
 482                         while dependency do
 483                                 if toadd ~= "" then
 484                                         toadd = toadd .. ","
 485                                 end
 486                                 toadd = toadd .. dependency
 487                                 dependency = dependencyfile:read()
 488                         end
 489                         dependencyfile:close()
 490                 end
 491         end
 492
 493         return toadd
 494 end
 495
 496
 497 --------------------------------------------------------------------------------
 498 function modmgr.get_worldconfig(worldpath)
 499         local filename = worldpath ..
 500                                 DIR_DELIM .. "world.mt"
 501
 502         local worldfile = io.open(filename,"r")
 503
 504         local worldconfig = {}
 505         worldconfig.global_mods = {}
 506         worldconfig.game_mods = {}
 507
 508         if worldfile then
 509                 local dependency = worldfile:read("*l")
 510                 while dependency do
 511                         local parts = dependency:split("=")
 512
 513                         local key = parts[1]:trim()
 514
 515                         if key == "gameid" then
 516                                 worldconfig.id = parts[2]:trim()
 517                         else
 518                                 local key = parts[1]:trim():sub(10)
 519                                 if parts[2]:trim() == "true" then
 520                                         worldconfig.global_mods[key] = true
 521                                 else
 522                                         worldconfig.global_mods[key] = false
 523                                 end
 524                         end
 525                         dependency = worldfile:read("*l")
 526                 end
 527                 worldfile:close()
 528         else
 529                 print("Modmgr: " .. filename .. " not found")
 530         end
 531
 532         --read gamemods
 533         local gamemodpath = engine.get_gamepath() .. DIR_DELIM .. worldconfig.id .. DIR_DELIM .. "mods"
 534
 535         get_mods(gamemodpath,worldconfig.game_mods)
 536
 537         return worldconfig
 538 end
 539 --------------------------------------------------------------------------------
 540 function modmgr.handle_modmgr_buttons(fields)
 541         local retval = {
 542                         tab = nil,
 543                         is_dialog = nil,
 544                         show_buttons = nil,
 545                 }
 546
 547         if fields["modlist"] ~= nil then
 548                 local event = explode_textlist_event(fields["modlist"])
 549                 modmgr.selected_mod = event.index
 550         end
 551
 552         if fields["btn_mod_mgr_install_local"] ~= nil then
 553                 engine.show_file_open_dialog("mod_mgt_open_dlg","Select Mod File:")
 554         end
 555
 556         if fields["btn_mod_mgr_download"] ~= nil then
 557                 retval.current_tab = "dialog_modstore_unsorted"
 558                 retval.is_dialog = true
 559                 retval.show_buttons = false
 560                 return retval
 561         end
 562
 563         if fields["btn_mod_mgr_rename_modpack"] ~= nil then
 564                 retval.current_tab = "dialog_rename_modpack"
 565                 retval.is_dialog = true
 566                 retval.show_buttons = false
 567                 return retval
 568         end
 569
 570         if fields["btn_mod_mgr_delete_mod"] ~= nil then
 571                 retval.current_tab = "dialog_delete_mod"
 572                 retval.is_dialog = true
 573                 retval.show_buttons = false
 574                 return retval
 575         end
 576
 577         if fields["mod_mgt_open_dlg_accepted"] ~= nil and
 578                 fields["mod_mgt_open_dlg_accepted"] ~= "" then
 579                 modmgr.installmod(fields["mod_mgt_open_dlg_accepted"],nil)
 580         end
 581
 582         return nil;
 583 end
 584
 585 --------------------------------------------------------------------------------
 586 function modmgr.installmod(modfilename,basename)
 587         local modfile = modmgr.identify_filetype(modfilename)
 588         local modpath = modmgr.extract(modfile)
 589
 590         if modpath == nil then
 591                 gamedata.errormessage = "Install Mod: file: " .. modfile.name ..
 592                         "\nInstall Mod: unsupported filetype \"" .. modfile.type .. "\""
 593                 return
 594         end
 595
 596
 597         local basefolder = modmgr.getbasefolder(modpath)
 598
 599         if basefolder.type == "modpack" then
 600                 local clean_path = nil
 601
 602                 if basename ~= nil then
 603                         clean_path = "mp_" .. basename
 604                 end
 605
 606                 if clean_path == nil then
 607                         clean_path = get_last_folder(cleanup_path(basefolder.path))
 608                 end
 609
 610                 if clean_path ~= nil then
 611                         local targetpath = engine.get_modpath() .. DIR_DELIM .. clean_path
 612                         if not engine.copy_dir(basefolder.path,targetpath) then
 613                                 gamedata.errormessage = "Failed to install " .. basename .. " to " .. targetpath
 614                         end
 615                 else
 616                         gamedata.errormessage = "Install Mod: unable to find suitable foldername for modpack "
 617                                 .. modfilename
 618                 end
 619         end
 620
 621         if basefolder.type == "mod" then
 622                 local targetfolder = basename
 623
 624                 if targetfolder == nil then
 625                         targetfolder = modmgr.identify_modname(basefolder.path,"init.lua")
 626                 end
 627
 628                 --if heuristic failed try to use current foldername
 629                 if targetfolder == nil then
 630                         targetfolder = get_last_folder(basefolder.path)
 631                 end
 632
 633                 if targetfolder ~= nil and modmgr.isValidModname(targetfolder) then
 634                         local targetpath = engine.get_modpath() .. DIR_DELIM .. targetfolder
 635                         engine.copy_dir(basefolder.path,targetpath)
 636                 else
 637                         gamedata.errormessage = "Install Mod: unable to find real modname for: "
 638                                 .. modfilename
 639                 end
 640         end
 641
 642         engine.delete_dir(modpath)
 643
 644         modmgr.refresh_globals()
 645
 646 end
 647
 648 --------------------------------------------------------------------------------
 649 function modmgr.handle_rename_modpack_buttons(fields)
 650
 651         if fields["dlg_rename_modpack_confirm"] ~= nil then
 652                 local mod = filterlist.get_list(modmgr.modlist)[modmgr.selected_mod]
 653                 local oldpath = engine.get_modpath() .. DIR_DELIM .. mod.name
 654                 local targetpath = engine.get_modpath() .. DIR_DELIM .. fields["te_modpack_name"]
 655                 engine.copy_dir(oldpath,targetpath,false)
 656         end
 657
 658         return {
 659                 is_dialog = false,
 660                 show_buttons = true,
 661                 current_tab = engine.setting_get("main_menu_tab")
 662                 }
 663 end
 664 --------------------------------------------------------------------------------
 665 function modmgr.handle_configure_world_buttons(fields)
 666         if fields["world_config_modlist"] ~= nil then
 667                 local event = explode_textlist_event(fields["world_config_modlist"])
 668                 modmgr.world_config_selected_mod = event.index
 669
 670                 if engine.setting_get("old_style_mod_selection") ~= "true" then
 671                         if event.typ == "DCL" then
 672                                 local mod = filterlist.get_list(modmgr.modlist)[event.index]
 673
 674                                 if mod.typ == "game_mod" then
 675                                         return nil
 676                                 end
 677
 678                                 if not mod.is_modpack then
 679                                         mod.enabled = not mod.enabled
 680                                 else
 681                                         local list = filterlist.get_raw_list(modmgr.modlist)
 682                                         local toset = nil
 683
 684                                         for i=1,#list,1 do
 685                                                 if list[i].modpack == mod.name then
 686                                                         if toset == nil then
 687                                                                 toset = not list[i].enabled
 688                                                         end
 689
 690                                                         list[i].enabled = toset
 691                                                 end
 692                                         end
 693                                 end
 694                         end
 695                 end
 696         end
 697
 698         if engine.setting_get("old_style_mod_selection") == "true" then
 699                 if fields["cb_mod_enable"] ~= nil then
 700                         local mod = filterlist.get_list(modmgr.modlist)
 701                                 [engine.get_textlist_index("world_config_modlist")]
 702                         if fields["cb_mod_enable"] == "true" then
 703                                 mod.enabled = true
 704                         else
 705                                 mod.enabled = false
 706                         end
 707                 end
 708
 709                 if fields["btn_mp_enable"] ~= nil or
 710                         fields["btn_mp_disable"] then
 711                         local mod = filterlist.get_list(modmgr.modlist)
 712                                 [engine.get_textlist_index("world_config_modlist")]
 713
 714                         local toset=false
 715                         if fields["btn_mp_enable"] ~= nil then
 716                                 toset = true
 717                         end
 718                         local list = filterlist.get_raw_list(modmgr.modlist)
 719
 720                         for i=1,#list,1 do
 721                                 if list[i].modpack == mod.name then
 722                                         list[i].enabled = toset
 723                                 end
 724                         end
 725                 end
 726         end
 727
 728         if fields["cb_hide_gamemods"] ~= nil then
 729                 local current = filterlist.get_filtercriteria(modmgr.modlist)
 730
 731                 if current == nil then
 732                         current = {}
 733                 end
 734
 735                 if fields["cb_hide_gamemods"] == "true" then
 736                         current.hide_game = true
 737                         modmgr.hide_gamemods = true
 738                 else
 739                         current.hide_game = false
 740                         modmgr.hide_gamemods = false
 741                 end
 742
 743                 filterlist.set_filtercriteria(modmgr.modlist,current)
 744         end
 745
 746                 if fields["cb_hide_mpcontent"] ~= nil then
 747                 local current = filterlist.get_filtercriteria(modmgr.modlist)
 748
 749                 if current == nil then
 750                         current = {}
 751                 end
 752
 753                 if fields["cb_hide_mpcontent"] == "true" then
 754                         current.hide_modpackcontents = true
 755                         modmgr.hide_modpackcontents = true
 756                 else
 757                         current.hide_modpackcontents = false
 758                         modmgr.hide_modpackcontents = false
 759                 end
 760
 761                 filterlist.set_filtercriteria(modmgr.modlist,current)
 762         end
 763
 764         if fields["btn_config_world_save"] then
 765                 local worldspec = engine.get_worlds()[modmgr.world_config_selected_world]
 766
 767                 local filename = worldspec.path ..
 768                                 DIR_DELIM .. "world.mt"
 769
 770                 local worldfile = io.open(filename,"w")
 771
 772                 if worldfile then
 773                         worldfile:write("gameid = " .. modmgr.worldconfig.id .. "\n")
 774
 775                         local rawlist = filterlist.get_raw_list(modmgr.modlist)
 776
 777                         for i=1,#rawlist,1 do
 778
 779                                 if not rawlist[i].is_modpack and
 780                                         rawlist[i].typ ~= "game_mod" then
 781                                         if rawlist[i].enabled then
 782                                                 worldfile:write("load_mod_" .. rawlist[i].name .. " = true" .. "\n")
 783                                         else
 784                                                 worldfile:write("load_mod_" .. rawlist[i].name .. " = false" .. "\n")
 785                                         end
 786                                 end
 787                         end
 788
 789                         worldfile:close()
 790                 else
 791                         print("failed to open world config file")
 792                 end
 793
 794                 modmgr.modlist = nil
 795                 modmgr.worldconfig = nil
 796
 797                 return {
 798                         is_dialog = false,
 799                         show_buttons = true,
 800                         current_tab = engine.setting_get("main_menu_tab")
 801                 }
 802         end
 803
 804         if fields["btn_config_world_cancel"] then
 805
 806                 modmgr.worldconfig = nil
 807
 808                 return {
 809                         is_dialog = false,
 810                         show_buttons = true,
 811                         current_tab = engine.setting_get("main_menu_tab")
 812                 }
 813         end
 814
 815         if fields["btn_all_mods"] then
 816                 local list = filterlist.get_raw_list(modmgr.modlist)
 817
 818                 for i=1,#list,1 do
 819                         if list[i].typ ~= "game_mod" and
 820                                 not list[i].is_modpack then
 821                                 list[i].enabled = true
 822                         end
 823                 end
 824         end
 825
 826
 827
 828         return nil
 829 end
 830 --------------------------------------------------------------------------------
 831 function modmgr.handle_delete_mod_buttons(fields)
 832         local mod = filterlist.get_list(modmgr.global_mods)[modmgr.selected_mod]
 833
 834         if fields["dlg_delete_mod_confirm"] ~= nil then
 835
 836                 if mod.path ~= nil and
 837                         mod.path ~= "" and
 838                         mod.path ~= engine.get_modpath() then
 839                         if not engine.delete_dir(mod.path) then
 840                                 gamedata.errormessage ="Modmgr: failed to delete >" .. mod.path .. "<"
 841                         end
 842                         modmgr.refresh_globals()
 843                 else
 844                         gamedata.errormessage ="Modmgr: invalid modpath >" .. mod.path .. "<"
 845                 end
 846         end
 847
 848         return {
 849                 is_dialog = false,
 850                 show_buttons = true,
 851                 current_tab = engine.setting_get("main_menu_tab")
 852                 }
 853 end
 854
 855 --------------------------------------------------------------------------------
 856 function modmgr.dialog_delete_mod()
 857
 858         local mod = filterlist.get_list(modmgr.global_mods)[modmgr.selected_mod]
 859
 860         local retval =
 861                 "field[1.75,1;10,3;;Are you sure you want to delete ".. mod.name .. "?;]"..
 862                 "button[4,4.2;1,0.5;dlg_delete_mod_confirm;Yes]" ..
 863                 "button[6.5,4.2;3,0.5;dlg_delete_mod_cancel;No of course not!]"
 864
 865         return retval
 866 end
 867
 868 --------------------------------------------------------------------------------
 869 function modmgr.preparemodlist(data)
 870         local retval = {}
 871
 872         local global_mods = {}
 873         local game_mods = {}
 874
 875         --read global mods
 876         local modpath = engine.get_modpath()
 877
 878         if modpath ~= nil and
 879                 modpath ~= "" then
 880                 get_mods(modpath,global_mods)
 881         end
 882
 883         for i=1,#global_mods,1 do
 884                 global_mods[i].typ = "global_mod"
 885                 table.insert(retval,global_mods[i])
 886         end
 887
 888         --read game mods
 889         if data.gameid ~= nil and
 890                 data.gameid ~= "" then
 891                 local gamemodpath = engine.get_gamepath() .. DIR_DELIM .. data.gameid .. DIR_DELIM .. "mods"
 892
 893                 get_mods(gamemodpath,game_mods)
 894         end
 895
 896         for i=1,#game_mods,1 do
 897                 game_mods[i].typ = "game_mod"
 898                 table.insert(retval,game_mods[i])
 899         end
 900
 901         if data.worldpath == nil then
 902                 return retval
 903         end
 904
 905         --read world mod configuration
 906         local filename = data.worldpath ..
 907                                 DIR_DELIM .. "world.mt"
 908
 909         local worldfile = io.open(filename,"r")
 910         if worldfile then
 911                 local dependency = worldfile:read("*l")
 912                 while dependency do
 913                         local parts = dependency:split("=")
 914
 915                         local key = parts[1]:trim()
 916
 917                         if key ~= "gameid" then
 918                                 local key = parts[1]:trim():sub(10)
 919                                 local element = nil
 920                                 for i=1,#retval,1 do
 921                                         if retval[i].name == key then
 922                                                 element = retval[i]
 923                                                 break
 924                                         end
 925                                 end
 926                                 if element ~= nil then
 927                                         if parts[2]:trim() == "true" then
 928                                                 element.enabled = true
 929                                         else
 930                                                 element.enabled = false
 931                                         end
 932                                 else
 933                                         print("Mod: " .. key .. " " .. dump(parts[2]) .. " but not found")
 934                                 end
 935                         end
 936                         dependency = worldfile:read("*l")
 937                 end
 938                 worldfile:close()
 939
 940         end
 941
 942         return retval
 943 end
 944
 945 --------------------------------------------------------------------------------
 946 function modmgr.init_worldconfig()
 947         modmgr.precheck()
 948         local worldspec = engine.get_worlds()[modmgr.world_config_selected_world]
 949
 950         if worldspec ~= nil then
 951                 --read worldconfig
 952                 modmgr.worldconfig = modmgr.get_worldconfig(worldspec.path)
 953
 954                 if modmgr.worldconfig.id == nil or
 955                         modmgr.worldconfig.id == "" then
 956                         modmgr.worldconfig = nil
 957                         return false
 958                 end
 959
 960                 modmgr.modlist = filterlist.create(
 961                                                 modmgr.preparemodlist, --refresh
 962                                                 modmgr.comparemod, --compare
 963                                                 function(element,uid) --uid match
 964                                                         if element.name == uid then
 965                                                                 return true
 966                                                         end
 967                                                 end,
 968                                                 function(element,criteria)
 969                                                         if criteria.hide_game and
 970                                                                 element.typ == "game_mod" then
 971                                                                         return false
 972                                                         end
 973
 974                                                         if criteria.hide_modpackcontents and
 975                                                                 element.modpack ~= nil then
 976                                                                         return false
 977                                                                 end
 978                                                         return true
 979                                                 end, --filter
 980                                                 { worldpath= worldspec.path,
 981                                                   gameid = worldspec.gameid }
 982                                         )
 983
 984                 filterlist.set_filtercriteria(modmgr.modlist, {
 985                                                                         hide_game=modmgr.hide_gamemods,
 986                                                                         hide_modpackcontents= modmgr.hide_modpackcontents
 987                                                                         })
 988
 989                 return true
 990         end
 991
 992         return false
 993 end
 994
 995 --------------------------------------------------------------------------------
 996 function modmgr.comparemod(elem1,elem2)
 997         if elem1 == nil or elem2 == nil then
 998                 return false
 999         end
1000         if elem1.name ~= elem2.name then
1001                 return false
1002         end
1003         if elem1.is_modpack ~= elem2.is_modpack then
1004                 return false
1005         end
1006         if elem1.typ ~= elem2.typ then
1007                 return false
1008         end
1009         if elem1.modpack ~= elem2.modpack then
1010                 return false
1011         end
1012
1013         if elem1.path ~= elem2.path then
1014                 return false
1015         end
1016
1017         return true
1018 end
1019
1020 --------------------------------------------------------------------------------
1021 function modmgr.gettab(name)
1022         local retval = ""
1023
1024         if name == "mod_mgr" then
1025                 retval = retval .. modmgr.tab()
1026         end
1027
1028         if name == "dialog_rename_modpack" then
1029                 retval = retval .. modmgr.dialog_rename_modpack()
1030         end
1031
1032         if name == "dialog_delete_mod" then
1033                 retval = retval .. modmgr.dialog_delete_mod()
1034         end
1035
1036         if name == "dialog_configure_world" then
1037                 retval = retval .. modmgr.dialog_configure_world()
1038         end
1039
1040         return retval
1041 end
1042
1043 --------------------------------------------------------------------------------
1044 function modmgr.mod_exists(basename)
1045
1046         if modmgr.global_mods == nil then
1047                 modmgr.refresh_globals()
1048         end
1049
1050         if filterlist.raw_index_by_uid(modmgr.global_mods,basename) > 0 then
1051                 return true
1052         end
1053
1054         return false
1055 end
1056
1057 --------------------------------------------------------------------------------
1058 function modmgr.get_global_mod(idx)
1059
1060         if modmgr.global_mods == nil then
1061                 return nil
1062         end
1063
1064         if idx < 1 or idx > filterlist.size(modmgr.global_mods) then
1065                 return nil
1066         end
1067
1068         return filterlist.get_list(modmgr.global_mods)[idx]
1069 end
1070
1071 --------------------------------------------------------------------------------
1072 function modmgr.refresh_globals()
1073         modmgr.global_mods = filterlist.create(
1074                                         modmgr.preparemodlist, --refresh
1075                                         modmgr.comparemod, --compare
1076                                         function(element,uid) --uid match
1077                                                 if element.name == uid then
1078                                                         return true
1079                                                 end
1080                                         end,
1081                                         nil, --filter
1082                                         {}
1083                                         )
1084 end
1085
1086 --------------------------------------------------------------------------------
1087 function modmgr.identify_filetype(name)
1088
1089         if name:sub(-3):lower() == "zip" then
1090                 return {
1091                                 name = name,
1092                                 type = "zip"
1093                                 }
1094         end
1095
1096         if name:sub(-6):lower() == "tar.gz" or
1097                 name:sub(-3):lower() == "tgz"then
1098                 return {
1099                                 name = name,
1100                                 type = "tgz"
1101                                 }
1102         end
1103
1104         if name:sub(-6):lower() == "tar.bz2" then
1105                 return {
1106                                 name = name,
1107                                 type = "tbz"
1108                                 }
1109         end
1110
1111         if name:sub(-2):lower() == "7z" then
1112                 return {
1113                                 name = name,
1114                                 type = "7z"
1115                                 }
1116         end
1117
1118         return {
1119                 name = name,
1120                 type = "ukn"
1121         }
1122 end