1:    2:    3:    4:    5:    6:    7:    8:    9:   10:   11:   12:   13:   14:   15:   16:   17:   18:   19:   20:   21:   22:   23:   24:   25:   26:   27:   28:   29:   30:   31:   32:   33:   34:   35:   36:   37:   38:   39:   40:   41:   42:   43:   44:   45:   46:   47:   48:   49:   50:   51:   52:   53:   54:   55:   56:   57:   58:   59:   60:   61:   62:   63:   64:   65:   66:   67:   68:   69:   70:   71:   72:   73:   74:   75:   76:   77:   78:   79:   80:   81:   82:   83:   84:   85:   86:   87:   88:   89:   90:   91:   92:   93:   94:   95:   96:   97:   98:   99:  100:  101:  102:  103:  104:  105:  106:  107:  108:  109:  110:  111:  112:  113:  114:  115:  116:  117:  118:  119:  120:  121:  122:  123:  124:  125:  126:  127:  128:  129:  130:  131:  132:  133:  134:  135:  136:  137:  138:  139:  140:  141:  142:  143:  144:  145:  146:  147:  148:  149:  150:  151:  152:  153:  154:  155:  156:  157:  158:  159:  160:  161:  162:  163:  164:  165:  166:  167:  168:  169:  170:  171:  172:  173:  174:  175:  176:  177:  178:  179:  180:  181:  182:  183:  184:  185:  186:  187:  188:  189:  190:  191:  192:  193:  194:  195:  196:  197:  198:  199:  200:  201:  202:  203:  204:  205:  206:  207:  208:  209:  210:  211:  212:  213:  214:  215:  216:  217:  218:  219:  220:  221:  222:  223:  224:  225:  226:  227:  228:  229:  230:  231:  232:  233:  234:  235:  236:  237:  238:  239:  240:  241:  242:  243:  244:  245:  246:  247:  248:  249:  250:  251:  252:  253:  254:  255:  256:  257:  258:  259:  260:  261:  262:  263:  264:  265:  266:  267:  268:  269:  270:  271:  272:  273:  274:  275:  276:  277:  278:  279:  280:  281:  282:  283:  284:  285:  286:  287:  288:  289:  290:  291:  292:  293:  294:  295:  296:  297:  298:  299:  300:  301:  302:  303:  304:  305:  306:  307:  308:  309:  310:  311:  312:  313:  314:  315:  316:  317:  318:  319:  320:  321:  322:  323:  324:  325:  326:  327:  328:  329:  330:  331:  332:  333:  334:  335:  336:  337:  338:  339:  340:  341:  342:  343:  344:  345:  346:  347:  348:  349:  350:  351:  352:  353:  354:  355:  356:  357:  358:  359:  360:  361:  362:  363:  364:  365:  366:  367:  368:  369:  370:  371:  372:  373:  374:  375:  376:  377:  378:  379:  380:  381:  382:  383:  384:  385:  386:  387:  388:  389:  390:  391:  392:  393:  394:  395:  396:  397:  398:  399:  400:  401:  402:  403:  404:  405:  406:  407:  408:  409:  410:  411:  412:  413:  414:  415:  416:  417:  418:  419:  420:  421:  422:  423:  424:  425:  426:  427:  428:  429:  430:  431:  432:  433:  434:  435:  436:  437:  438:  439:  440:  441:  442:  443:  444:  445:  446:  447:  448:  449:  450:  451:  452:  453:  454:  455:  456:  457:  458:  459:  460:  461:  462:  463:  464:  465:  466:  467:  468:  469:  470:  471:  472:  473:  474:  475:  476:  477:  478:  479:  480:  481:  482:  483:  484:  485:  486:  487:  488:  489:  490:  491:  492:  493:  494:  495:  496:  497:  498:  499:  500:  501:  502:  503:  504:  505:  506:  507:  508:  509:  510:  511:  512:  513:  514:  515:  516:  517:  518:  519:  520:  521:  522:  523:  524:  525:  526:  527:  528:  529:  530:  531:  532:  533:  534:  535:  536:  537:  538:  539:  540:  541:  542:  543:  544:  545:  546:  547:  548:  549:  550:  551:  552:  553:  554:  555:  556:  557:  558:  559:  560:  561:  562:  563:  564:  565:  566:  567:  568:  569:  570:  571:  572:  573:  574:  575:  576:  577:  578:  579:  580:  581:  582:  583:  584:  585:  586:  587:  588:  589:  590:  591:  592:  593:  594:  595:  596:  597:  598:  599:  600:  601:  602:  603:  604:  605:  606:  607:  608:  609:  610:  611:  612:  613:  614:  615:  616:  617:  618:  619:  620:  621:  622:  623:  624:  625:  626:  627:  628:  629:  630:  631:  632:  633:  634:  635:  636:  637:  638:  639:  640:  641:  642:  643:  644:  645:  646:  647:  648:  649:  650:  651:  652:  653:  654:  655:  656:  657:  658:  659:  660:  661:  662:  663:  664:  665:  666:  667:  668:  669:  670:  671:  672:  673:  674:  675:  676:  677:  678:  679:  680:  681:  682:  683:  684:  685:  686:  687:  688:  689:  690:  691:  692:  693:  694:  695:  696:  697:  698:  699:  700:  701:  702:  703:  704:  705:  706:  707:  708:  709:  710:  711:  712:  713:  714:  715:  716:  717:  718:  719:  720:  721:  722:  723:  724:  725:  726:  727:  728:  729:  730:  731:  732:  733:  734:  735:  736:  737:  738:  739:  740:  741:  742:  743:  744:  745:  746:  747:  748:  749:  750:  751:  752:  753:  754:  755:  756:  757:  758:  759:  760:  761:  762:  763:  764:  765:  766:  767:  768:  769:  770:  771:  772:  773:  774:  775:  776:  777:  778:  779:  780:  781:  782:  783:  784:  785:  786:  787:  788:  789:  790:  791:  792:  793:  794:  795:  796:  797:  798:  799:  800:  801:  802:  803:  804:  805:  806:  807:  808:  809:  810:  811:  812:  813:  814:  815:  816:  817:  818:  819:  820:  821:  822:  823:  824:  825:  826:  827:  828:  829:  830:  831:  832:  833:  834:  835:  836:  837:  838:  839:  840:  841:  842:  843:  844:  845:  846:  847:  848:  849:  850:  851:  852:  853:  854:  855:  856:  857:  858:  859:  860:  861:  862:  863:  864:  865:  866:  867:  868:  869:  870:  871:  872:  873:  874:  875:  876:  877:  878:  879:  880:  881:  882:  883:  884:  885:  886:  887:  888:  889:  890:  891:  892:  893:  894:  895:  896:  897:  898:  899:  900:  901:  902:  903:  904:  905:  906:  907:  908:  909:  910:  911:  912:  913:  914:  915:  916:  917:  918:  919:  920:  921:  922:  923:  924:  925:  926:  927:  928:  929:  930:  931:  932:  933:  934:  935:  936:  937:  938:  939:  940:  941:  942:  943:  944:  945:  946:  947:  948:  949:  950:  951:  952:  953:  954:  955:  956:  957:  958:  959:  960:  961:  962:  963:  964:  965:  966:  967:  968:  969:  970:  971:  972:  973:  974:  975:  976:  977:  978:  979:  980:  981:  982:  983:  984:  985:  986:  987:  988:  989:  990:  991:  992:  993:  994:  995:  996:  997:  998:  999: 1000: 1001: 1002: 1003: 1004: 1005: 1006: 1007: 1008: 1009: 1010: 1011: 1012: 1013: 1014: 1015: 1016: 1017: 1018: 1019: 1020: 1021: 1022: 1023: 1024: 1025: 1026: 1027: 1028: 1029: 1030: 1031: 1032: 1033: 1034: 1035: 1036: 1037: 1038: 1039: 1040: 1041: 1042: 1043: 1044: 1045: 1046: 1047: 1048: 1049: 1050: 1051: 1052: 1053: 1054: 1055: 1056: 1057: 1058: 1059: 1060: 1061: 1062: 1063: 1064: 1065: 1066: 1067: 1068: 1069: 1070: 1071: 1072: 1073: 1074: 1075: 1076: 1077: 1078: 1079: 1080: 1081: 1082: 1083: 1084: 1085: 1086: 1087: 1088: 1089: 1090: 1091: 1092: 1093: 1094: 1095: 1096: 1097: 1098: 1099: 1100: 1101: 1102: 1103: 1104: 1105: 1106: 1107: 1108: 1109: 1110: 1111: 1112: 1113: 1114: 1115: 1116: 1117: 1118: 1119: 1120: 1121: 1122: 1123: 1124: 1125: 1126: 1127: 1128: 1129: 1130: 1131: 1132: 1133: 1134: 1135: 1136: 1137: 1138: 1139: 1140: 1141: 1142: 1143: 1144: 1145: 1146: 1147: 1148: 1149: 1150: 1151: 1152: 1153: 1154: 1155: 1156: 1157: 1158: 1159: 1160: 1161: 1162: 1163: 1164: 1165: 1166: 1167: 1168: 1169: 1170: 1171: 1172: 1173: 1174: 1175: 1176: 1177: 1178: 1179: 1180: 1181: 1182: 1183: 1184: 1185: 1186: 1187: 1188: 1189: 1190: 1191: 1192: 1193: 1194: 1195: 1196: 1197: 1198: 1199: 1200: 1201: 1202: 1203: 1204: 1205: 1206: 1207: 1208: 1209: 1210: 1211: 1212: 1213: 1214: 1215: 1216: 1217: 1218: 1219: 1220: 1221: 1222: 1223: 1224: 1225: 1226: 1227: 1228: 1229: 1230: 1231: 1232: 1233: 1234: 1235: 1236: 1237: 1238: 1239: 1240: 1241: 1242: 1243: 1244: 1245: 1246: 1247: 1248: 1249: 1250: 1251: 1252: 1253: 1254: 1255: 1256: 1257: 1258: 1259: 1260: 1261: 1262: 1263: 1264: 1265: 1266: 1267: 1268: 1269: 1270: 1271: 1272: 1273: 1274: 1275: 1276: 1277: 1278: 1279: 1280: 1281: 1282: 1283: 1284: 1285: 1286: 1287: 1288: 1289: 1290: 1291: 1292: 1293: 1294: 1295: 1296: 1297: 1298: 1299: 1300: 1301: 1302: 1303: 1304: 1305: 1306: 1307: 1308: 1309: 1310: 1311: 1312: 1313: 1314: 1315: 1316: 1317: 1318: 1319: 1320: 1321: 1322: 1323: 1324: 1325: 1326: 1327: 1328: 1329: 1330: 1331: 1332: 1333: 1334: 1335: 1336: 1337: 1338: 1339: 1340: 1341: 1342: 1343: 1344: 1345: 1346: 1347: 1348: 1349: 1350: 1351: 1352: 1353: 1354: 1355: 1356: 1357: 1358: 1359: 1360: 1361: 1362: 1363: 1364: 1365: 1366: 1367: 1368: 1369: 1370: 1371: 1372: 1373: 1374: 1375: 1376: 1377: 1378: 1379: 1380: 1381: 1382: 1383: 1384: 1385: 1386: 1387: 1388: 1389: 1390: 1391: 1392: 1393: 1394: 1395: 1396: 1397: 1398: 1399: 1400: 1401: 1402: 1403: 1404: 1405: 1406: 1407: 1408: 1409: 1410: 1411: 1412: 1413: 1414: 1415: 1416: 1417: 1418: 1419: 1420: 1421: 1422: 1423: 1424: 1425: 1426: 1427: 1428: 1429: 1430: 1431: 1432: 1433: 1434: 1435: 1436: 1437: 1438: 1439: 1440: 1441: 1442: 1443: 1444: 1445: 1446: 1447: 1448: 1449: 1450: 1451: 1452: 1453: 1454: 1455: 1456: 1457: 1458: 1459: 1460: 1461: 1462: 1463: 1464: 1465: 1466: 1467: 1468: 1469: 1470: 1471: 1472: 1473: 1474: 1475: 1476: 1477: 1478: 1479: 1480: 1481: 1482: 1483: 1484: 1485: 1486: 1487: 1488: 1489: 1490: 1491: 1492: 1493: 1494: 1495: 1496: 1497: 1498: 1499: 1500: 1501: 1502: 1503: 1504: 1505: 1506: 1507: 1508: 1509: 1510: 1511: 1512: 1513: 1514: 1515: 1516: 1517: 1518: 1519: 1520: 1521: 1522: 1523: 1524: 1525: 1526: 1527: 1528: 1529: 1530: 1531: 1532: 1533: 1534: 1535: 1536: 1537: 1538: 1539: 1540: 1541: 1542: 1543: 1544: 1545: 1546: 1547: 1548: 1549: 1550: 1551: 1552: 1553: 1554: 1555: 1556: 1557: 1558: 1559: 1560: 1561: 1562: 1563: 1564: 1565: 1566: 1567: 1568: 1569: 1570: 1571: 1572: 1573: 1574: 1575: 1576: 1577: 1578: 1579: 1580: 1581: 1582: 1583: 1584: 1585: 1586: 1587: 1588: 1589: 1590: 1591: 1592: 1593: 1594: 1595: 1596: 1597: 1598: 1599: 1600: 1601: 1602: 1603: 1604: 1605: 1606: 1607: 1608: 1609: 1610: 1611: 1612: 1613: 1614: 1615: 1616: 1617: 1618: 1619: 1620: 1621: 1622: 1623: 1624: 1625: 1626: 1627: 1628: 1629: 1630: 1631: 1632: 1633: 1634: 1635: 1636: 1637: 1638: 1639: 1640: 1641: 1642: 1643: 1644: 1645: 1646: 1647: 1648: 1649: 1650: 1651: 1652: 1653: 1654: 1655: 1656: 1657: 1658: 1659: 1660: 1661: 1662: 1663: 1664: 1665: 1666: 1667: 1668: 1669: 1670: 1671: 1672: 1673: 1674: 1675: 1676: 1677: 1678: 1679: 1680: 1681: 1682: 1683: 1684: 1685: 1686: 1687: 1688: 1689: 1690: 1691: 1692: 1693: 1694: 1695: 1696: 1697: 1698: 1699: 1700: 1701: 1702: 1703: 1704: 1705: 1706: 1707: 1708: 1709: 1710: 1711: 1712: 1713: 1714: 1715: 1716: 1717: 1718: 1719: 1720: 1721: 1722: 1723: 1724: 1725: 1726: 1727: 1728: 1729: 1730: 1731: 1732: 1733: 1734: 1735: 1736: 1737: 1738: 1739: 1740: 1741: 1742: 1743: 1744: 1745: 1746: 1747: 1748: 1749: 1750: 1751: 1752: 1753: 1754: 1755: 1756: 1757: 1758: 1759: 1760: 1761: 1762: 1763: 1764: 1765: 1766: 1767: 1768: 1769: 1770: 1771: 1772: 1773: 1774: 1775: 1776: 1777: 1778: 1779: 1780: 1781: 1782: 1783: 1784: 1785: 1786: 1787: 1788: 1789: 1790: 1791: 1792: 1793: 1794: 1795: 1796: 1797: 1798: 1799: 1800: 1801: 1802: 1803: 1804: 1805: 1806: 1807: 1808: 1809: 1810: 1811: 1812: 1813: 1814: 1815: 1816: 1817: 1818: 1819: 1820: 1821: 1822: 1823: 1824: 1825: 1826: 1827: 1828: 1829: 1830: 1831: 1832: 1833: 1834: 1835: 1836: 1837: 1838: 1839: 1840: 1841: 1842: 1843: 1844: 1845: 1846: 1847: 1848: 1849: 1850: 1851: 1852: 1853: 1854: 1855: 1856: 1857: 1858: 1859: 1860: 1861: 1862: 1863: 1864: 1865: 1866: 1867: 1868: 1869: 1870: 1871: 1872: 1873: 1874: 1875: 1876: 1877: 1878: 1879: 1880: 1881: 1882: 1883: 1884: 1885: 1886: 1887: 1888: 1889: 1890: 1891: 1892: 1893: 1894: 1895: 1896: 1897: 1898: 1899: 1900: 1901: 1902: 1903: 1904: 1905: 1906: 1907: 1908: 1909: 1910: 1911: 1912: 1913: 1914: 1915: 1916: 1917: 1918: 1919: 1920: 1921: 1922: 1923: 1924: 1925: 1926: 1927: 1928: 1929: 1930: 1931: 1932: 1933: 1934: 1935: 1936: 1937: 1938: 1939: 1940: 1941: 1942: 1943: 1944: 1945: 1946: 1947: 1948: 1949: 1950: 1951: 1952: 1953: 1954: 1955: 1956: 1957: 1958: 1959: 1960: 1961: 1962: 1963: 

<?php


// force UTF-8 Ø

define('IMAGE_SORT_DIRECTION', getOption('image_sortdirection'));
define('IMAGE_SORT_TYPE', getOption('image_sorttype'));

Gallery::addAlbumHandler('alb', 'dynamicAlbum');

/**
 * Wrapper instantiation function for albums. Do not instantiate directly
 * @param string $folder8 the name of the folder (inernal character set)
 * @param bool $cache true if the album should be fetched from the cache
 * @param bool $quiet true to supress error messages
 * @return Album
 */
function newAlbum($folder8, $cache = true, $quiet = false) {
    global $_zp_albumHandlers;
    $suffix = getSuffix($folder8);
    if (!$suffix || !array_key_exists($suffix, $_zp_albumHandlers) || is_dir(ALBUM_FOLDER_SERVERPATH . internalToFilesystem($folder8))) {
        return new Album($folder8, $cache, $quiet);
    } else {
        return new $_zp_albumHandlers[$suffix]($folder8, $cache, $quiet);
    }
}

/**
 * Returns true if the object is a zenphoto 'album'
 *
 * @param object $album
 * @return bool
 */
function isAlbumClass($album = NULL) {
    global $_zp_current_album;
    if (is_null($album)) {
        if (!in_context(ZP_ALBUM))
            return false;
        $album = $_zp_current_album;
    }
    return is_object($album) && ($album->table == 'albums');
}

/**
 * Album Base Class
 * @package core
 * @subpackage classes\objects
 */
class AlbumBase extends MediaObject {

    public $name; // Folder name of the album (full path from the albums folder)
    public $linkname; // may have the .alb suffix stripped off
    public $localpath; // Latin1 full server path to the album
    public $exists = true; // Does the folder exist?
    public $images = null; // Full images array storage.
    public $parent = null; // The parent album name
    public $parentalbum = null; // The parent album's album object (lazy)
    public $parentalbums = null; // Array of objects of parent albums (lazy)
    public $sidecars = array(); // keeps the list of suffixes associated with this album
    public $manage_rights = MANAGE_ALL_ALBUM_RIGHTS;
    public $manage_some_rights = ALBUM_RIGHTS;
    public $view_rights = ALL_ALBUMS_RIGHTS;
    protected $subalbums = null; // Full album array storage.
    protected $index;
    protected $lastimagesort = NULL; // remember the order for the last album/image sorts
    protected $lastsubalbumsort = NULL;
    protected $albumthumbnail = NULL; // remember the album thumb for the duration of the script
    protected $subrights = NULL; // cache for album subrights
    protected $num_allalbums = null; // count of all subalbums of all sublevels
    protected $num_allimages = null; // count of all images of all sublevels
    protected $is_public = null;

    function __construct($folder8, $cache = true) {
        $this->linkname = $this->name = $folder8;
        $this->instantiate('albums', array('folder' => $this->name), 'folder', false, true);
        $this->exists = false;
    }

    /**
     * Sets default values for a new album
     *
     * @return bool
     */
    protected function setDefaults() {
        global $_zp_gallery;
        if (TEST_RELEASE) {
            $bt = debug_backtrace();
            $good = false;
            foreach ($bt as $b) {
                if ($b['function'] == "newAlbum") {
                    $good = true;
                    break;
                }
            }
            if (!$good) {
                zp_error(gettext('An album object was instantiated without using the newAlbum() function.'), E_USER_WARNING);
            }
        }
// Set default data for a new Album (title and parent_id)
        $parentalbum = NULL;
        $this->setShow($_zp_gallery->getAlbumPublish());
        $this->set('mtime', time());
        $this->setLastChange();
        $title = trim($this->name);
        $this->set('title', sanitize($title, 2));
        return true;
    }

    /**
     * Returns the folder on the filesystem
     *
     * @return string
     */
    function getFileName() {
        return $this->name;
    }

    /**
     * Returns the folder on the filesystem
     *
     * @return string
     */
    function getFolder() {
        return $this->name;
    }

    /**
     * Returns The parent Album of this Album. NULL if this is a top-level album.
     *
     * @return object
     */
    function getParent() {
        if (is_null($this->parentalbum)) {
            $slashpos = strrpos($this->name, "/");
            if ($slashpos) {
                $parent = substr($this->name, 0, $slashpos);
                $parentalbum = newAlbum($parent, true, true);
                if ($parentalbum->exists) {
                    return $parentalbum;
                }
            }
        } else if ($this->parentalbum->exists) {
            return $this->parentalbum;
        }
        return NULL;
    }
    
    /**
     * Gets an array of parent album objects
     * 
     * @since Zenphoto 1.5.5
     * 
     * @return array|null
     */
    function getParents() {
        if (is_null($this->parentalbums)) {
            $parents = array();
            $album = $this;
            while (!is_null($album = $album->getParent())) {
                array_unshift($parents, $album);
            }
            return $this->parentalbums = $parents;
        } else {
            return $this->parentalbums;
        }
    }


    function getParentID() {
        return $this->get('parentid');
    }

    /**
     * Returns the place data of an album
     *
     * @return string
     */
    function getLocation($locale = NULL) {
        $text = $this->get('location');
        if ($locale !== 'all') {
            $text = get_language_string($text, $locale);
        }
        $text = unTagURLs($text);
        return $text;
    }

    /**
     * Stores the album place
     *
     * @param string $place text for the place field
     */
    function setLocation($place) {
        $this->set('location', tagURLs($place));
    }

    /**
     * Returns either the subalbum sort direction or the image sort direction of the album
     *
     * @param string $what 'image_' if you want the image direction,
     *        'album' if you want it for the album
     *
     * @return string
     */
    function getSortDirection($what = 'image') {
        global $_zp_gallery;
        if ($what == 'image') {
            $direction = $this->get('image_sortdirection');
            $type = $this->get('sort_type');
        } else {
            $direction = $this->get('album_sortdirection');
            $type = $this->get('subalbum_sort_type');
        }
        if (empty($type)) {
// using inherited type, so use inherited direction
            $parentalbum = $this->getParent();
            if (is_null($parentalbum)) {
                if ($what == 'image') {
                    $direction = IMAGE_SORT_DIRECTION;
                } else {
                    $direction = $_zp_gallery->getSortDirection();
                }
            } else {
                $direction = $parentalbum->getSortDirection($what);
            }
        }
        return $direction;
    }

    /**
     * Returns the sort type of the album images
     * Will return a parent sort type if the sort type for this album is empty
     *
     * @return string
     */
    function getSortType($what = 'image') {
        global $_zp_gallery;
        if ($what == 'image') {
            $type = $this->get('sort_type');
        } else {
            $type = $this->get('subalbum_sort_type');
        }
        if (empty($type)) {
            $parentalbum = $this->getParent();
            if (is_null($parentalbum)) {
                if ($what == 'image') {
                    $type = IMAGE_SORT_TYPE;
                } else {
                    $type = $_zp_gallery->getSortType();
                }
            } else {
                $type = $parentalbum->getSortType($what);
            }
        }
        return $type;
    }

    /**
     * sets sort directions for the album
     *
     * @param bool $val the direction
     * @param string $what 'image_sortdirection' if you want the image direction,
     *        'album_sortdirection' if you want it for the album
     */
    function setSortDirection($val, $what = 'image') {
        if ($what == 'image') {
            $this->set('image_sortdirection', (int) ($val && true));
        } else {
            $this->set('album_sortdirection', (int) ($val && true));
        }
    }

    /**
     * Stores the sort type for the album
     *
     * @param string $sorttype the album sort type
     * @param string $what 'Description'image' or 'album'
     */
    function setSortType($sorttype, $what = 'image') {
        if ($what == 'image') {
            $this->set('sort_type', $sorttype);
        } else {
            $this->set('subalbum_sort_type', $sorttype);
        }
    }

    /**
     * Returns the DB key associated with the image sort type
     *
     * @param string $sorttype the sort type
     * @return string
     */
    function getImageSortKey($sorttype = null) {
        if (is_null($sorttype)) {
            $sorttype = $this->getSortType();
        }
        return lookupSortKey($sorttype, 'filename', 'images');
    }

    /**
     * Returns the DB key associated with the subalbum sort type
     *
     * @param string $sorttype subalbum sort type
     * @return string
     */
    function getAlbumSortKey($sorttype = null) {
        if (empty($sorttype)) {
            $sorttype = $this->getSortType('album');
        }
        return lookupSortKey($sorttype, 'sort_order', 'albums');
    }

    /**
     * Returns all folder names for all the subdirectories.
     *
     * @param string $page  Which page of subalbums to display.
     * @param string $sorttype The sort strategy
     * @param string $sortdirection The direction of the sort
     * @param bool $care set to false if the order does not matter
     * @param bool $mine set true/false to override ownership
     * @return array
     */
    function getAlbums($page = 0, $sorttype = null, $sortdirection = null, $care = true, $mine = NULL) {
        if ($page == 0) {
            return $this->subalbums;
        } else {
            $albums_per_page = max(1, getOption('albums_per_page'));
            return array_slice($this->subalbums, $albums_per_page * ($page - 1), $albums_per_page);
        }
    }

    /**
     * Returns the count of direct child subalbums
     *
     * @return int
     */
    function getNumAlbums() {
        return count($this->getAlbums(0, NULL, NULL, false));
    }
    
    /**
     * Returns the count of all subalbums of all sublevels
     * Note that dynamic albums are not counted
     * 
     * @since Zenphoto 1.5.2
     */
    function getNumAllAlbums() {
        if (!is_null($this->num_allalbums)) {
            return $this->num_allalbums;
        } else {
            $count = $this->getNumAlbums();
            $subalbums = $this->getAlbums();
            foreach ($subalbums as $folder) {
                $subalbum = newAlbum($folder);
                if (!$subalbum->isDynamic()) {
                    $count += $subalbum->getNumAllAlbums();
                }
            }
            return $count;
        }
    }

    /**
     * Returns a of a slice of the images for this album. They will
     * also be sorted according to the sort type of this album, or by filename if none
     * has been set.
     *
     * @param string $page  Which page of images should be returned. If zero, all images are returned.
     * @param int $firstPageCount count of images that go on the album/image transition page
     * @param string $sorttype optional sort type
     * @param string $sortdirection optional sort direction
     * @param bool $care set to false if the order of the images does not matter
     * @param bool $mine set true/false to override ownership
     *
     * @return array
     */
    function getImages($page = 0, $firstPageCount = 0, $sorttype = null, $sortdirection = null, $care = true, $mine = NULL) {
// Return the cut of images based on $page. Page 0 means show all.
        if ($page == 0) {
            return $this->images;
        } else {
// Only return $firstPageCount images if we are on the first page and $firstPageCount > 0
            if (($page == 1) && ($firstPageCount > 0)) {
                $pageStart = 0;
                $images_per_page = $firstPageCount;
            } else {
                if ($firstPageCount > 0) {
                    $fetchPage = $page - 2;
                } else {
                    $fetchPage = $page - 1;
                }
                $images_per_page = max(1, getOption('images_per_page'));
                $pageStart = (int) ($firstPageCount + $images_per_page * $fetchPage);
            }
            return array_slice($this->images, $pageStart, $images_per_page);
        }
    }

    /**
     * Returns the number of images in this album (not counting its subalbums)
     *
     * @return int
     */
    function getNumImages() {
        if (is_null($this->images)) {
            return count($this->getImages(0, 0, NULL, NULL, false));
        }
        return count($this->images);
    }
    
    /**
     * Returns the number of images in this album and subalbums of all levels
     * Note that dynamic albums are not counted.
     * 
     * @since Zenphoto 1.5.2
     */
    function getNumAllImages() {
        if (!is_null($this->num_allimages)) {
            return $this->num_allimages;
        } else {
            $count = $this->getNumImages();
            $subalbums = $this->getAlbums();
            foreach ($subalbums as $folder) {
                $subalbum = newAlbum($folder);
                if (!$subalbum->isDynamic()) {
                    $count += $subalbum->getNumAllImages();
                }
            }
            return $count;
        }
    }

    /**
     * Returns an image from the album based on the index passed.
     *
     * @param int $index
     * @return int
     */
    function getImage($index) {
        $images = $this->getImages();
        if ($index >= 0 && $index < count($images)) {
            return newImage($this, $this->images[$index]);
        }
        return false;
    }

    /**
     * Gets the album's set thumbnail image from the database if one exists,
     * otherwise, finds the first image in the album or sub-album and returns it
     * as an Image object.
     *
     * @return Image
     */
    function getAlbumThumbImage() {
        global $_zp_albumthumb_selector, $_zp_gallery;

        if (!is_null($this->albumthumbnail)) {
            return $this->albumthumbnail;
        }

        $albumdir = $this->localpath;
        $thumb = $this->get('thumb');
        if (is_null($thumb)) {
            $this->set('thumb', $thumb = getOption('AlbumThumbSelect'));
        }
        $i = strpos($thumb, '/');
        if ($root = ($i === 0)) {
            $thumb = substr($thumb, 1); // strip off the slash
            $albumdir = ALBUM_FOLDER_SERVERPATH;
        }
        if (!empty($thumb) && !is_numeric($thumb)) {
            if (file_exists($albumdir . internalToFilesystem($thumb))) {
                if ($i === false) {
                    return newImage($this, $thumb);
                } else {
                    $pieces = explode('/', $thumb);
                    $i = count($pieces);
                    $thumb = $pieces[$i - 1];
                    unset($pieces[$i - 1]);
                    $albumdir = implode('/', $pieces);
                    if (!$root) {
                        $albumdir = $this->name . "/" . $albumdir;
                    } else {
                        $albumdir = $albumdir . "/";
                    }
                    $this->albumthumbnail = newImage(newAlbum($albumdir), $thumb);
                    return $this->albumthumbnail;
                }
            } else {
                $this->set('thumb', $thumb = getOption('AlbumThumbSelect'));
            }
        }
        if ($shuffle = empty($thumb)) {
            $thumbs = $this->getImages(0, 0, NULL, NULL, false);
        } else {
            $thumbs = $this->getImages(0, 0, $_zp_albumthumb_selector[(int) $thumb]['field'], $_zp_albumthumb_selector[(int) $thumb]['direction']);
        }
        if (!is_null($thumbs)) {
            if ($shuffle) {
                shuffle($thumbs);
            }
            $mine = $this->isMyItem(LIST_RIGHTS);
            $other = NULL;
            while (count($thumbs) > 0) {
                // first check for images
                $thumb = array_shift($thumbs);
                $thumb = newImage($this, $thumb);
                if ($mine || $thumb->isPublished()) {
                    if (isImagePhoto($thumb)) {
                        // legitimate image
                        $this->albumthumbnail = $thumb;
                        return $this->albumthumbnail;
                    } else {
                        if (!is_null($thumb->objectsThumb)) {
                            //  "other" image with a thumb sidecar
                            $this->albumthumbnail = $thumb;
                            return $this->albumthumbnail;
                        } else {
                            if (is_null($other)) {
                                $other = $thumb;
                            }
                        }
                    }
                }
            }
            if (!is_null($other)) {
                //  "other" image, default thumb
                $this->albumthumbnail = $other;
                return $this->albumthumbnail;
            }
        }

        // Otherwise, look in sub-albums.
        $subalbums = $this->getAlbums();
        if (!is_null($subalbums)) {
            if ($shuffle) {
                shuffle($subalbums);
            }
            while (count($subalbums) > 0) {
                $folder = array_pop($subalbums);
                $subalbum = newAlbum($folder);
                $pwd = $subalbum->getPassword();
                if (($subalbum->isPublished() && empty($pwd)) || $subalbum->isMyItem(LIST_RIGHTS)) {
                    $thumb = $subalbum->getAlbumThumbImage();
                    if (strtolower(get_class($thumb)) !== 'transientimage' && $thumb->exists) {
                        $this->albumthumbnail = $thumb;
                        return $thumb;
                    }
                }
            }
        }

        $nullimage = SERVERPATH . '/' . ZENFOLDER . '/images/imageDefault.png';
        // check for theme imageDefault.png
        $theme = '';
        $uralbum = getUralbum($this);
        $albumtheme = $uralbum->getAlbumTheme();
        if (!empty($albumtheme)) {
            $theme = $albumtheme;
        } else {
            $theme = $_zp_gallery->getCurrentTheme();
        }
        if (!empty($theme)) {
            $themeimage = SERVERPATH . '/' . THEMEFOLDER . '/' . $theme . '/images/imageDefault.png';
            if (file_exists(internalToFilesystem($themeimage))) {
                $nullimage = $themeimage;
            }
        }

        $this->albumthumbnail = new transientimage($this, $nullimage);
        return $this->albumthumbnail;
    }

    /**
     * Gets the thumbnail URL for the album thumbnail image as returned by $this->getAlbumThumbImage();
     * @return string
     */
    function getThumb() {
        $image = $this->getAlbumThumbImage();
        return $image->getThumb('album');
    }

    /**
     * Stores the thumbnail path for an album thumg
     *
     * @param string $filename thumbnail path
     */
    function setThumb($filename) {
        $this->set('thumb', $filename);
    }

    /**
     * Returns an URL to the album, including the current page number
     *
     * @param string $page if not null, apppend as page #
     * @return string
     */
    function getLink($page = NULL) {
        global $_zp_current_album;
        global $_zp_page;
        if (is_null($page) && $_zp_current_album && $_zp_current_album->name == $this->name) {
            $page = $_zp_page;
        }
        $rewrite = pathurlencode($this->linkname) . '/';
        $plain = '/index.php?album=' . pathurlencode($this->name);
        if ($page > 1) {
            $rewrite .=_PAGE_ . '/' . $page . '/';
            $plain .= "&page=$page";
        }
        return zp_apply_filter('getLink', rewrite_path($rewrite, $plain), $this, $page);
    }

    /**
     * Delete the entire album PERMANENTLY. Be careful! This is unrecoverable.
     * Returns true if successful
     *
     * @return bool
     */
    function remove() {
        $rslt = false;
        if (PersistentObject::remove()) {
            query("DELETE FROM " . prefix('options') . "WHERE `ownerid`=" . $this->id);
            query("DELETE FROM " . prefix('comments') . "WHERE `type`='albums' AND `ownerid`=" . $this->id);
            query("DELETE FROM " . prefix('obj_to_tag') . "WHERE `type`='albums' AND `objectid`=" . $this->id);
            $rslt = true;
            $filestoremove = safe_glob(substr($this->localpath, 0, -1) . '.*');
            foreach ($filestoremove as $file) {
                if (in_array(strtolower(getSuffix($file)), $this->sidecars)) {
                    @chmod($file, 0777);
                    unlink($file);
                }
            }
            $this->setUpdatedDateParents();
        }
        return $rslt;
    }

    /**
     * common album move code
     * @param type $newfolder
     * @return int
     */
    protected function _move($newfolder) {
        // First, ensure the new base directory exists.
        $dest = ALBUM_FOLDER_SERVERPATH . internalToFilesystem($newfolder);
        // Check to see if the destination already exists
        if (file_exists($dest)) {
            // Disallow moving an album over an existing one.
            if (!(CASE_INSENSITIVE && strtolower($dest) == strtolower(rtrim($this->localpath, '/')))) {
                return 3;
            }
        }
        if(!$this->isValidMoveCopyDestination($newfolder)) {
            // Disallow moving to a subfolder of the current folder.
            return 4;
        }
        $filemask = substr($this->localpath, 0, -1) . '.*';
        $perms = FOLDER_MOD;
        @chmod($this->localpath, 0777);
        $success = @rename(rtrim($this->localpath, '/'), $dest);
        @chmod($dest, $perms);

        if ($success) {
            $this->localpath = $dest . "/";
            $filestomove = safe_glob($filemask);
            foreach ($filestomove as $file) {
                if (in_array(strtolower(getSuffix($file)), $this->sidecars)) {
                    $d = stripslashes($dest) . '.' . getSuffix($file);
                    @chmod($file, 0777);
                    $success = $success && @rename($file, $d);
                    @chmod($d, FILE_MOD);
                }
            }
            clearstatcache();
            $success = self::move($newfolder);
            if ($success) {
                // Update old parent(s) that "lost" an album!
                $this->setUpdatedDateParents(); 
                $this->save();
                
                $this->updateParent($newfolder);
        
                //rename the cache folder
                $cacherename = @rename(SERVERCACHE . '/' . $this->name, SERVERCACHE . '/' . $newfolder);
                return 0;
            }
        }
        return 1;
    }
    
    

    /**
     * Move this album to the location specified by $newfolder, copying all
     * metadata, subalbums, and subalbums' metadata with it.
     * @param $newfolder string the folder to move to, including the name of the current folder (possibly renamed).
     * @return int 0 on success and error indicator on failure.
     *
     */
    function move($newfolder) {
        return parent::move(array('folder' => $newfolder));
    }

    /**
     * Rename this album folder. Alias for move($newfoldername);
     * @param string $newfolder the new folder name of this album (including subalbum paths)
     * @return boolean true on success or false on failure.
     */
    function rename($newfolder) {
        return $this->move($newfolder);
    }

    protected function succeed($dest) {
        return false;
    }

    /**
     * Copy this album to the location specified by $newfolder, copying all
     * metadata, subalbums, and subalbums' metadata with it.
     * @param $newfolder string the folder to copy to, including the name of the current folder (possibly renamed).
     * @return int 0 on success and error indicator on failure.
     *
     */
    function copy($newfolder) {
        // album name to destination folder
        if (substr($newfolder, -1, 1) != '/') {
            $newfolder .= '/';
        }
        $newfolder .= basename($this->localpath);
        // First, ensure the new base directory exists.
        $dest = ALBUM_FOLDER_SERVERPATH . internalToFilesystem($newfolder);
        // Check to see if the destination directory already exists
        if (file_exists($dest)) {
            // Disallow moving an album over an existing one.
            return 3;
        }
        if(!$this->isValidMoveCopyDestination($newfolder)) {
            // Disallow copying to a subfolder of the current folder (infinite loop).
            return 4;
        }
        $success = $this->succeed($dest);
        $filemask = substr($this->localpath, 0, -1) . '.*';
        if ($success) {
            // replicate the album metadata and sub-files
            $uniqueset = array('folder' => $newfolder);
            $parentname = dirname($newfolder);  
            if (empty($parentname) || $parentname == '/' || $parentname == '.') {
                $uniqueset['parentid'] = NULL;
            } else {
                $parent = newAlbum($parentname);    
                $uniqueset['parentid'] = $parent->getID();
            }
            $newID = parent::copy($uniqueset);
            if ($newID) {
                //replicate the tags
                storeTags(readTags($this->getID(), 'albums'), $newID, 'albums');
                //copy the sidecar files
                $filestocopy = safe_glob($filemask);
                foreach ($filestocopy as $file) {
                    if (in_array(strtolower(getSuffix($file)), $this->sidecars)) {
                        $success = $success && @copy($file, dirname($dest) . '/' . basename($file));
                    }
                }
                
            }
        }
        if ($success) { 
            $newalbum = newAlbum($newfolder);
            $newalbum->setUpdatedDate();
            $newalbum->setUpdatedDateParents();
            return 0;
        } else {
            return 1;
        }
    }
    
    /**
     * Checks is the destination is not a subfolder of the current folder itself
     * 
     * @since Zenphoto 1.5.5
     * 
     * @param string $destination album name to move or copy to
     * @return boolean
     */
    function isValidMoveCopyDestination($destination) {
        $oldfolders = explode('/', $this->name);
        $newfolders = explode('/', $destination);
        $sub = count($newfolders) > count($oldfolders);
        if ($sub) {
            for ($i = 0; $i < count($oldfolders); $i++) {
                if ($newfolders[$i] != $oldfolders[$i]) {
                    $sub = false;
                    break;
                }
            }
            if ($sub) {
                // Disallow moving to a subfolder of the current folder.
                return false;
            }
        }
        return true;
    }

    /**
     * For every image in the album, look for its file. Delete from the database
     * if the file does not exist. Same for each sub-directory/album.
     *
     * @param bool $deep set to true for a thorough cleansing
     */
    function garbageCollect($deep = false) {

    }

    /**
     * Load all of the filenames that are found in this Albums directory on disk.
     * Returns an array with all the names.
     *
     * @param  $dirs Whether or not to return directories ONLY with the file array.
     * @return array
     */
    protected function loadFileNames($dirs = false) {

    }

    /**
     * Returns true if the album is "dynamic"
     *
     * @return bool
     */
    function isDynamic() {
        return false;
    }

    /**
     * Returns the search parameters for a dynamic album
     *
     * @return string
     */
    function getSearchParams() {
        return NULL;
    }

    /**
     * Sets the search parameters of a dynamic album
     *
     * @param string $params The search string to produce the dynamic album
     */
    function setSearchParams($params) {

    }

    /**
     * Returns the search engine for a dynamic album
     *
     * @return object
     */
    function getSearchEngine() {
        return NULL;
    }

    /**
     * checks access to the album
     * @param bit $action What the requestor wants to do
     *
     * returns true of access is allowed
     */
    function isMyItem($action) {
        global $_zp_loggedin;
        if ($parent = parent::isMyItem($action)) {
            return $parent;
        }
        if (zp_loggedin($action)) {
            $subRights = $this->albumSubRights();
            if (is_null($subRights)) {
// no direct rights, but if this is a private gallery and the album is published he should be allowed to see it
                if (GALLERY_SECURITY != 'public' && $this->isPublished() && $action == LIST_RIGHTS) {
                    return LIST_RIGHTS;
                }
            } else {
                $albumrights = LIST_RIGHTS;
                if ($subRights & (MANAGED_OBJECT_RIGHTS_EDIT)) {
                    $albumrights = $albumrights | ALBUM_RIGHTS;
                }
                if ($subRights & MANAGED_OBJECT_RIGHTS_UPLOAD) {
                    $albumrights = $albumrights | UPLOAD_RIGHTS;
                }
                if ($action & $albumrights) {
                    return ($_zp_loggedin ^ (ALBUM_RIGHTS | UPLOAD_RIGHTS)) | $albumrights;
                } else {
                    return false;
                }
            }
        }
        return false;
    }

    /**
     * Checks if guest is loggedin for the album
     * @param unknown_type $hint
     * @param unknown_type $show
     */
    function checkforGuest(&$hint = NULL, &$show = NULL) {
        if (!parent::checkForGuest()) {
            return false;
        }
        return checkAlbumPassword($this, $hint);
    }

    /**
     *
     * returns true if there is any protection on the album
     */
    function isProtected() {
        return $this->checkforGuest() != 'zp_public_access';
    }
    
        
    /**
     * Returns true if this album is published and also all of its parents.
     * 
     * @since Zenphoto 1.5.5
     * 
     * @return bool
     */
    function isPublic() {
        if (is_null($this->is_public)) {
            if (!$this->isPublished()) {
                return $this->is_public = false;
            }
            $parent = $this->getParent();
            if($parent && !$parent->isPublic()) {
                return $this->is_public = false;
            }
            return $this->is_public = true;
        } else {
            return $this->is_public;
        }
    }

    /**
     * Gets the owner of the album respectively of a parent album if not set specifically
     * 
     * @global obj $_zp_authority
     * @param bool $fullname Set to true to get the full name (if the owner is a vaild user of the site and has the full name defined)
     * @return string
     */
    function getOwner($fullname = false) {
        global $_zp_authority;
        $owner = $this->get('owner');
        if (empty($owner)) {
            $p = $this->getParent();
            if (is_object($p)) {
                $owner = $p->getOwner();
            } else {
                $admin = $_zp_authority->getMasterUser();
                $owner = $admin->getUser();
                if ($fullname && !empty($admin->getName())) {
                    return $admin->getName();
                }
            }
        } else {
            if ($fullname) {
                return Zenphoto_Administrator::getNameByUser($owner);
            }
        }
        return $owner;
    }

    function setOwner($owner) {
        $this->set('owner', $owner);
    }

    /**
     *
     * Date at which the album last discovered an image
     */
    function getUpdatedDate() {
        return $this->get('updateddate');
    }

    function setUpdatedDate($date = null) {
        if(is_null($date)) {
            $date = date('Y-m-d H:i:s');
        }
        return $this->set('updateddate', $date);
    }
    
    /**
     * Sets the current date to all parent albums of this album recursively
     * @since Zenphoto 1.5.5
     */
    function setUpdatedDateParents() {
        $parent = $this->getParent();
        if($parent) {
            $parent->setUpdatedDate();
            $parent->save();
            $parent->setUpdatedDateParents();
        }
    }

    /**
     * Returns the theme for the album
     *
     * @return string
     */
    function getAlbumTheme() {
        global $_zp_gallery;
        if (in_context(ZP_SEARCH_LINKED)) {
            return $_zp_gallery->getCurrentTheme();
        } else {
            return $this->get('album_theme');
        }
    }

    /**
     * Sets the theme of the album
     *
     * @param string $theme
     */
    function setAlbumTheme($theme) {
        $this->set('album_theme', $theme);
    }

    /**
     * returns the album watermark
     * @return string
     */
    function getWatermark() {
        return $this->get('watermark');
    }

    /**
     * Sets the album watermark
     * @param string $wm
     */
    function setWatermark($wm) {
        $this->set('watermark', $wm);
    }

    /**
     * Returns the album watermark thumb
     *
     * @return bool
     */
    function getWatermarkThumb() {
        return $this->get('watermark_thumb');
    }

    /**
     * Sets the custom watermark usage
     *
     * @param $wm
     */
    function setWatermarkThumb($wm) {
        $this->set('watermark_thumb', $wm);
    }

    /**
     * returns the mitigated album rights.
     * returns NULL if not a managed album
     */
    function albumSubRights() {
        if (!is_null($this->subrights)) {
            return $this->subrights;
        }
        global $_zp_admin_album_list;
        if (zp_loggedin(MANAGE_ALL_ALBUM_RIGHTS)) {
            $this->subrights = MANAGED_OBJECT_RIGHTS_EDIT | MANAGED_OBJECT_RIGHTS_UPLOAD | MANAGED_OBJECT_RIGHTS_VIEW;
            return $this->subrights;
        }
        if (zp_loggedin(VIEW_UNPUBLISHED_RIGHTS)) {
            $base = MANAGED_OBJECT_RIGHTS_VIEW;
        } else {
            $base = NULL;
        }
        getManagedAlbumList();
        if (count($_zp_admin_album_list) > 0) {
            $desired_folders = explode('/', $this->name);
            foreach ($_zp_admin_album_list as $adminalbum => $rights) {
// see if it is one of the managed folders or a subfolder there of
                $admin_folders = explode('/', $adminalbum);
                $level = 0;
                $ok = true;
                foreach ($admin_folders as $folder) {
                    if ($level >= count($desired_folders) || $folder != $desired_folders[$level]) {
                        $ok = false;
                        break;
                    }
                    $level++;
                }
                if ($ok) {
                    $this->subrights = $rights | $base;
                    return $this->subrights;
                }
            }
        }
        $this->subrights = $base;
        return $this->subrights;
    }

    /**
     * sortImageArray will sort an array of Images based on the given key. The
     * key must be one of (filename, title, sort_order) at the moment.
     *
     * @param array $images The array of filenames to be sorted.
     * @param  string $sorttype optional sort type
     * @param  string $sortdirection optional sort direction
     * @param bool $mine set to true/false to override ownership clause
     * @return array
     */
    protected function sortImageArray($images, $sorttype, $sortdirection, $mine = NULL) {
        if (is_null($mine)) {
            $mine = $this->isMyItem(LIST_RIGHTS | MANAGE_ALL_ALBUM_RIGHTS);
        }
        if ($mine && !($mine & (MANAGE_ALL_ALBUM_RIGHTS))) {
            //check for managed album view unpublished image rights
            $mine = $this->albumSubRights() & (MANAGED_OBJECT_RIGHTS_EDIT | MANAGED_OBJECT_RIGHTS_VIEW);
        }
        $sortkey = $this->getImageSortKey($sorttype);
        if (($sortkey == '`sort_order`') || ($sortkey == 'RAND()')) {
            // manual sort is always ascending
            $order = false;
        } else {
            if (!is_null($sortdirection)) {
                $order = strtoupper($sortdirection) == 'DESC';
            } else {
                $order = $this->getSortDirection('image');
            }
        }
        $result = query($sql = "SELECT * FROM " . prefix("images") . " WHERE `albumid`= " . $this->getID() . ' ORDER BY ' . $sortkey . ' ' . $sortdirection);
        $results = array();
        while ($row = db_fetch_assoc($result)) {
            $filename = $row['filename'];
            if (($key = array_search($filename, $images)) !== false) {
                // the image exists in the filesystem
                $results[] = $row;
                unset($images[$key]);
            } else { // the image no longer exists
                $id = $row['id'];
                query("DELETE FROM " . prefix('images') . " WHERE `id`=$id"); // delete the record
                query("DELETE FROM " . prefix('comments') . " WHERE `type` ='images' AND `ownerid`= '$id'"); // remove image comments
            }
        }
        db_free_result($result);
        foreach ($images as $filename) {
            // these images are not in the database
            $imageobj = newImage($this, $filename);
            $results[] = $imageobj->getData();
        }
        // now put the results into the right order
        $results = sortByKey($results, str_replace('`', '', $sortkey), $order);
        // the results are now in the correct order
        $images_ordered = array();
        foreach ($results as $key => $row) {
            // check for visible
            switch (themeObject::checkScheduledPublishing($row)) {
                case 1:
                    $imageobj = newImage($this, $row['filename']);
                    $imageobj->setShow(0);
                    $imageobj->save();
                case 2:
                    $row['show'] = 0;
                    break;
            }
            if ($row['show'] || $mine) {
                // don't display it
                $images_ordered[] = $row['filename'];
            }
        }
        return $images_ordered;
    }

    /**
     * changes the parent of an album for move/copy
     *
     * @param string $newfolder The folder name of the new parent
     */
    protected function updateParent($newfolder) {
        $this->name = $newfolder;
        $parentname = dirname($newfolder);
        if ($parentname == '/' || $parentname == '.')
            $parentname = '';
        if (empty($parentname)) {
            $this->set('parentid', NULL);
        } else {
            $parent = newAlbum($parentname);
            $this->set('parentid', $parent->getID());
        }
        $this->setUpdatedDateParents();
        $this->save();
    }

    /**
     * Simply creates objects of all the images and sub-albums in this album to
     * load accurate values into the database.
     */
    function preLoad() {
        $images = $this->getImages(0);
        $subalbums = $this->getAlbums(0);
        foreach ($subalbums as $dir) {
            $album = newAlbum($dir);
            $album->preLoad();
        }
    }

    /**
     * Returns the album following the current album
     *
     * @return object
     */
    function getNextAlbum() {
        global $_zp_gallery;
        if (is_null($parent = $this->getParent())) {
            $albums = $_zp_gallery->getAlbums(0);
        } else {
            $albums = $parent->getAlbums(0);
        }
        $inx = array_search($this->name, $albums) + 1;
        if ($inx >= 0 && $inx < count($albums)) {
            return newAlbum($albums[$inx]);
        }
        return null;
    }

    /**
     * Returns the album prior to the current album
     *
     * @return object
     */
    function getPrevAlbum() {
        global $_zp_gallery;
        if (is_null($parent = $this->getParent())) {
            $albums = $_zp_gallery->getAlbums(0);
        } else {
            $albums = $parent->getAlbums(0);
        }
        $inx = array_search($this->name, $albums) - 1;
        if ($inx >= 0 && $inx < count($albums)) {
            return newAlbum($albums[$inx]);
        }
        return null;
    }

    /**
     * Returns the page number in the gallery or the parent album of this album 
     *
     * @return int
     */
    function getGalleryPage() {
        global $_zp_gallery;
        if ($this->index == null) {
            if (is_null($parent = $this->getParent())) {
                $albums = $_zp_gallery->getAlbums(0);
            } else {
                $albums = $parent->getAlbums(0);
            }
            $this->index = array_search($this->name, $albums);
        }
        return floor(($this->index / galleryAlbumsPerPage()) + 1);
    }
    
}

/**
 * Album Class
 * @package core
 * @subpackage classes\objects
 */
class Album extends AlbumBase {

    /**
     * Constructor for albums
     *
     * @param object $gallery The parent gallery: deprecated
     * @param string $folder8 folder name (UTF8) of the album
     * @param bool $cache load from cache if present
     * @return Album
     */
    function __construct($folder8, $cache = true, $quiet = false) {
        $folder8 = trim($folder8, '/');
        $folderFS = internalToFilesystem($folder8);
        $localpath = ALBUM_FOLDER_SERVERPATH . $folderFS . "/";
        $this->linkname = $this->name = $folder8;
        $this->localpath = $localpath;
        if (!$this->_albumCheck($folder8, $folderFS, $quiet))
            return;

        $new = $this->instantiate('albums', array('folder' => $this->name), 'folder', $cache, empty($folder8));

        if ($new) {
            $this->setUpdatedDateParents();
            $this->save();
            zp_apply_filter('new_album', $this);
        }
        zp_apply_filter('album_instantiate', $this);
    }

    /**
     * album validity check
     * @return boolean
     */
    protected function _albumCheck($folder8, $folderFS, $quiet) {
        $msg = false;
        if (empty($folder8)) {
            $msg = gettext('Invalid album instantiation: No album name');
        } else if (filesystemToInternal($folderFS) != $folder8) {
            // an attempt to spoof the album name.
            $msg = sprintf(gettext('Invalid album instantiation: %1$s!=%2$s'), html_encode(filesystemToInternal($folderFS)), html_encode($folder8));
        } else if (!file_exists($this->localpath) || !(is_dir($this->localpath)) || $folder8[0] == '.' || preg_match('~/\.*/~', $folder8)) {
            $msg = sprintf(gettext('Invalid album instantiation: %s does not exist.'), html_encode($folder8));
        }
        if ($msg) {
            $this->exists = false;
            if (!$quiet) {
                trigger_error($msg, E_USER_ERROR);
            }
            return false;
        }
        return true;
    }

    /**
     * Sets default values for a new album
     *
     * @return bool
     */
    protected function setDefaults() {
        global $_zp_gallery;
        // Set default data for a new Album (title and parent_id)
        parent::setDefaults();
        $parentalbum = $this->getParent();
        $this->set('mtime', filemtime($this->localpath));
        if (!$_zp_gallery->getAlbumUseImagedate()) {
            $this->setDateTime(strftime('%Y-%m-%d %H:%M:%S', $this->get('mtime')));
        }
        $title = trim($this->name);
        if (!is_null($parentalbum)) {
            $this->set('parentid', $parentalbum->getID());
            $title = substr($title, strrpos($title, '/') + 1);
        }
        $this->set('title', sanitize($title, 2));
        return true;
    }

    /**
     * Guts of fetching the subalbums
     * @return array
     */
    protected function _getAlbums() {
        $dirs = $this->loadFileNames(true);
        $subalbums = array();
        foreach ($dirs as $dir) {
            $dir = $this->name . '/' . $dir;
            $subalbums[] = $dir;
        }
        return $subalbums;
    }

    /**
     * Returns all folder names for all the subdirectories.
     *
     * @param string $page  Which page of subalbums to display.
     * @param string $sorttype The sort strategy
     * @param string $sortdirection The direction of the sort
     * @param bool $care set to false if the order does not matter
     * @param bool $mine set true/false to override ownership
     * @return array
     */
    function getAlbums($page = 0, $sorttype = null, $sortdirection = null, $care = true, $mine = NULL) {
        global $_zp_gallery;
        if (!$this->exists)
            return array();
        if ($mine || is_null($this->subalbums) || $care && $sorttype . $sortdirection !== $this->lastsubalbumsort) {
            if (is_null($sorttype)) {
                $sorttype = $this->getSortType('album');
            }
            if (is_null($sortdirection)) {
                if ($this->getSortDirection('album')) {
                    $sortdirection = 'DESC';
                } 
            }
            $dirs = $this->loadFileNames(true);
            $subalbums = array();
            foreach ($dirs as $dir) {
                $dir = $this->name . '/' . $dir;
                $subalbums[] = $dir;
            }
            $key = $this->getAlbumSortKey($sorttype);
            $this->subalbums = $_zp_gallery->sortAlbumArray($this, $subalbums, $key, $sortdirection, $mine);
            $this->lastsubalbumsort = $sorttype . $sortdirection;
        }
        return parent::getAlbums($page);
    }

    /**
     * Returns a of a slice of the images for this album. They will
     * also be sorted according to the sort type of this album, or by filename if none
     * has been set.
     *
     * @param int $page  Which page of images should be returned. If zero, all images are returned.
     * @param int $firstPageCount count of images that go on the album/image transition page
     * @param string $sorttype optional sort type
     * @param string $sortdirection optional sort direction
     * @param bool $care set to false if the order of the images does not matter
     * @param bool $mine set true/false to override ownership
     *
     * @return array
     */
    function getImages($page = 0, $firstPageCount = 0, $sorttype = null, $sortdirection = null, $care = true, $mine = NULL) {
        if (!$this->exists)
            return array();
        if ($mine || is_null($this->images) || $care && $sorttype . $sortdirection !== $this->lastimagesort) {
            if (is_null($sorttype)) {
                $sorttype = $this->getSortType();
            }
            if (is_null($sortdirection)) {
                if ($this->getSortDirection('image')) {
                    $sortdirection = 'DESC';
                } 
            }
            $images = $this->loadFileNames();
            $this->images = $this->sortImageArray($images, $sorttype, $sortdirection, $mine);
            $this->lastimagesort = $sorttype . $sortdirection;
        }
        return parent::getImages($page, $firstPageCount);
    }

    /**
     * Delete the entire album PERMANENTLY. Be careful! This is unrecoverable.
     * Returns true if successful
     *
     * @return bool
     */
    function remove() {
        $rslt = false;
        if (PersistentObject::remove()) {
            foreach ($this->getImages() as $filename) {
                $image = newImage($this, $filename);
                $image->remove();
            }
            foreach ($this->getAlbums() as $folder) {
                $subalbum = newAlbum($folder);
                $subalbum->remove();
            }
            $curdir = getcwd();
            chdir($this->localpath);
            $filelist = safe_glob('*');
            foreach ($filelist as $file) {
                if (($file != '.') && ($file != '..')) {
                    @chmod($file, 0777);
                    unlink($this->localpath . $file); // clean out any other files in the folder
                }
            }
            chdir($curdir);
            clearstatcache();
            query("DELETE FROM " . prefix('options') . "WHERE `ownerid`=" . $this->id);
            query("DELETE FROM " . prefix('comments') . "WHERE `type`='albums' AND `ownerid`=" . $this->id);
            query("DELETE FROM " . prefix('obj_to_tag') . "WHERE `type`='albums' AND `objectid`=" . $this->id);
            $success = true;
            $filestoremove = safe_glob(substr($this->localpath, 0, strrpos($this->localpath, '.')) . '.*');
            foreach ($filestoremove as $file) {
                if (in_array(strtolower(getSuffix($file)), $this->sidecars)) {
                    @chmod($file, 0777);
                    $success = $success && unlink($file);
                }
            }
            @chmod($this->localpath, 0777);
            $rslt = @rmdir($this->localpath) && $success;
            $cachepath = SERVERCACHE . '/' . pathurlencode($this->name) . '/';
            @chmod($cachepath, 0777);
            @rmdir($cachepath);
            $this->setUpdatedDateParents();
        }
        clearstatcache();
        return $rslt;
    }

    /**
     * Move this album to the location specified by $newfolder, copying all
     * metadata, subalbums, and subalbums' metadata with it.
     * @param $newfolder string the folder to move to, including the name of the current folder (possibly renamed).
     * @return int 0 on success and error indicator on failure.
     *
     */
    function move($newfolder) {
        $oldfolder = $this->name;
        $rslt = $this->_move($newfolder);
        if (!$rslt) {
            // Then: go through the db and change the album (and subalbum) paths. No ID changes are necessary for a move.
            // Get the subalbums.
            $sql = "SELECT id, folder FROM " . prefix('albums') . " WHERE folder LIKE " . db_quote(db_LIKE_escape($oldfolder) . '/%');
            $result = query($sql);
            if ($result) {
                while ($subrow = db_fetch_assoc($result)) {
                    $newsubfolder = $subrow['folder'];
                    $newsubfolder = $newfolder . substr($newsubfolder, strlen($oldfolder));
                    $sql = "UPDATE " . prefix('albums') . " SET folder=" . db_quote($newsubfolder) . " WHERE id=" . $subrow['id'];
                    query($sql);
                }
            }
            db_free_result($result);
            return 0;
        }
        return $rslt;
    }

    protected function succeed($dest) {
        return mkdir_recursive($dest, FOLDER_MOD) === TRUE;
    }

    /**
     * Copy this album to the location specified by $newfolder, copying all
     * metadata, subalbums, and subalbums' metadata with it.
     * @param $newfolder string the folder to copy to, including the name of the current folder (possibly renamed).
     * @return int 0 on success and error indicator on failure.
     *
     */
    function copy($newfolder) {
        $rslt = parent::copy($newfolder);
        if (!$rslt) {
            $newfolder .= '/' . basename($this->name);
            $success = true;
            //copy the images
            $images = $this->getImages(0);
            foreach ($images as $imagename) {
                $image = newImage($this, $imagename);
                if ($rslt = $image->copy($newfolder)) {
                    $success = false;
                }
            }
            // copy the subalbums.
            $subalbums = $this->getAlbums(0);
            foreach ($subalbums as $subalbumname) {
                $subalbum = newAlbum($subalbumname);
                if ($rslt = $subalbum->copy($newfolder)) {
                    $success = false;
                }
            }
            if ($success) {
                return 0;
            }
            return 1;
        }
        return $rslt;
    }

    /**
     * For every image in the album, look for its file. Delete from the database
     * if the file does not exist. Same for each sub-directory/album.
     *
     * @param bool $deep set to true for a thorough cleansing
     */
    function garbageCollect($deep = false) {
        $set_updateddate = false;
        if (is_null($this->images))
            $this->getImages();
        $result = query("SELECT `id`, `filename` FROM " . prefix('images') . " WHERE `albumid` = '" . $this->id . "'");
        $dead = array();
        $live = array();

        $files = $this->loadFileNames();

        // Does the filename from the db row match any in the files on disk?
        while ($row = db_fetch_assoc($result)) {
            if (!in_array($row['filename'], $files)) {
                // In the database but not on disk. Kill it.
                $dead[] = $row['id'];
            } else if (in_array($row['filename'], $live)) {
                // Duplicate in the database. Kill it.
                $dead[] = $row['id'];
                // Do something else here? Compare titles/descriptions/metadata/update dates to see which is the latest?
            } else {
                $live[] = $row['filename'];
            }
        }
        db_free_result($result);

        if (count($dead) > 0) {
            $sql = "DELETE FROM " . prefix('images') . " WHERE `id` IN(" . implode(',', $dead) . ")";
            $sql2 = "DELETE FROM " . prefix('comments') . " WHERE `type`='albums' AND `ownerid` IN(" . implode(',', $dead) . ")";
            query($sql);
            query($sql2);
            $set_updateddate = true;
        }

        // Get all sub-albums and make sure they exist.
        $result = query("SELECT `id`, `folder` FROM " . prefix('albums') . " WHERE `folder` LIKE " . db_quote(db_LIKE_escape($this->name) . '%'));
        $dead = array();
        $live = array();
        // Does the dirname from the db row exist on disk?
        while ($row = db_fetch_assoc($result)) {
            if (!is_dir(ALBUM_FOLDER_SERVERPATH . internalToFilesystem($row['folder'])) || in_array($row['folder'], $live) || substr($row['folder'], -1) == '/' || substr($row['folder'], 0, 1) == '/') {
                $dead[] = $row['id'];
            } else {
                $live[] = $row['folder'];
            }
        }
        db_free_result($result);
        if (count($dead) > 0) {
            $sql = "DELETE FROM " . prefix('albums') . " WHERE `id` IN(" . implode(',', $dead) . ")";
            $sql2 = "DELETE FROM " . prefix('comments') . " WHERE `type`='albums' AND `ownerid` IN(" . implode(',', $dead) . ")";
            query($sql);
            query($sql2);
            $set_updateddate = true;
        }
        if($set_updateddate) {
            $this->setUpdateddate();
            $this->save();
            $this->setUpdatedDateParents();
        } 

        if ($deep) {
            foreach ($this->getAlbums(0) as $dir) {
                $subalbum = newAlbum($dir);
                // Could have been deleted if it didn't exist above...
                if ($subalbum->exists)
                    $subalbum->garbageCollect($deep);
            }
        }
    }

    /**
     * Load all of the filenames that are found in this Albums directory on disk.
     * Returns an array with all the names.
     *
     * @param  $dirs Whether or not to return directories ONLY with the file array.
     * @return array
     */
    protected function loadFileNames($dirs = false) {
        clearstatcache();
        $albumdir = $this->localpath;
        $dir = @opendir($albumdir);
        if (!$dir) {
            if (is_dir($albumdir)) {
                $msg = sprintf(gettext("Error: The album %s is not readable."), html_encode($this->name));
            } else {
                $msg = sprintf(gettext("Error: The album named %s cannot be found."), html_encode($this->name));
            }
            trigger_error($msg, E_USER_NOTICE);
            return array();
        }

        $files = array();
        $others = array();

        while (false !== ($file = readdir($dir))) {
            $file8 = filesystemToInternal($file);
            if (@$file8[0] != '.') {
                if ($dirs && (is_dir($albumdir . $file) || hasDynamicAlbumSuffix($file))) {
                    $files[] = $file8;
                } else if (!$dirs && is_file($albumdir . $file)) {
                    if (Gallery::validImageAlt($file)) {
                        $files[] = $file8;
                        $others[] = $file8;
                    } else if (Gallery::validImage($file)) {
                        $files[] = $file8;
                    }
                }
            }
        }
        closedir($dir);
        if (count($others) > 0) {
            $others_thumbs = array();
            foreach ($others as $other) {
                $others_root = substr($other, 0, strrpos($other, "."));
                foreach ($files as $image) {
                    if ($image != $other) {
                        $image_root = substr($image, 0, strrpos($image, "."));
                        if ($image_root == $others_root && Gallery::validImage($image)) {
                            $others_thumbs[] = $image;
                        }
                    }
                }
            }
            $files = array_diff($files, $others_thumbs);
        }

        if ($dirs) {
            return zp_apply_filter('album_filter', $files);
        } else {
            return zp_apply_filter('image_filter', $files);
        }
    }
    

}

/**
 * Dynamic Album Class for "saved searches"
 * @package core
 * @subpackage classes\objects
 */
class dynamicAlbum extends AlbumBase {

    public $searchengine; // cache the search engine for dynamic albums

    function __construct($folder8, $cache = true, $quiet = false) {
        $folder8 = trim($folder8, '/');
        $folderFS = internalToFilesystem($folder8);
        $localpath = ALBUM_FOLDER_SERVERPATH . $folderFS . "/";
        $this->linkname = $this->name = $folder8;
        $this->localpath = $localpath;
        if (!$this->_albumCheck($folder8, $folderFS, $quiet))
            return;
        $this->instantiate('albums', array('folder' => $this->name), 'folder', $cache, empty($folder8));
        $this->exists = true;
        if (!is_dir(stripSuffix($this->localpath))) {
            $this->linkname = stripSuffix($folder8);
        }
        $new = !$this->get('search_params');
        if ($new || (filemtime($this->localpath) > $this->get('mtime'))) {
            $constraints = '';
            $data = file_get_contents($this->localpath);
            while (!empty($data)) {
                $data1 = trim(substr($data, 0, $i = strpos($data, "\n")));
                if ($i === false) {
                    $data1 = $data;
                    $data = '';
                } else {
                    $data = substr($data, $i + 1);
                }
                if (strpos($data1, 'WORDS=') !== false) {
                    $words = "words=" . urlencode(substr($data1, 6));
                }
                if (strpos($data1, 'THUMB=') !== false) {
                    $thumb = trim(substr($data1, 6));
                    $this->set('thumb', $thumb);
                }
                if (strpos($data1, 'FIELDS=') !== false) {
                    $fields = "&searchfields=" . trim(substr($data1, 7));
                }
                if (strpos($data1, 'CONSTRAINTS=') !== false) {
                    $constraint = trim(substr($data1, 12));
                    $constraints = '&' . $constraint;
                }
            }
            if (!empty($words)) {
                if (empty($fields)) {
                    $fields = '&searchfields=tags';
                }
                $this->set('search_params', $words . $fields . $constraints);
            }
            $this->set('mtime', filemtime($this->localpath));
            if ($new) {
                $title = $this->get('title');
                $this->set('title', stripSuffix($title)); // Strip the suffix
                $this->save();
                zp_apply_filter('new_album', $this);
            }
        }
        zp_apply_filter('album_instantiate', $this);
    }

    /**
     * album validity check
     * @param type $folder8
     * @return boolean
     */
    protected function _albumCheck($folder8, $folderFS, $quiet) {
        $this->localpath = rtrim($this->localpath, '/');

        $msg = false;
        if (empty($folder8)) {
            $msg = gettext('Invalid album instantiation: No album name');
        } else if (filesystemToInternal($folderFS) != $folder8) {
            // an attempt to spoof the album name.
            $msg = sprintf(gettext('Invalid album instantiation: %1$s!=%2$s'), html_encode(filesystemToInternal($folderFS)), html_encode($folder8));
        } else if (!file_exists($this->localpath) || is_dir($this->localpath)) {
            $msg = sprintf(gettext('Invalid album instantiation: %s does not exist.'), html_encode($folder8));
        }
        if ($msg) {
            $this->exists = false;
            if (!$quiet) {
                trigger_error($msg, E_USER_ERROR);
            }
            return false;
        }
        return true;
    }

    /**
     * Returns all folder names for all the subdirectories.
     *
     * @param string $page  Which page of subalbums to display.
     * @param string $sorttype The sort strategy
     * @param string $sortdirection The direction of the sort
     * @param bool $care set to false if the order does not matter
     * @param bool $mine set true/false to override ownership
     * @return array
     */
    function getAlbums($page = 0, $sorttype = null, $sortdirection = null, $care = true, $mine = NULL) {
        global $_zp_gallery;
        if (!$this->exists)
            return array();
        if ($mine || is_null($this->subalbums) || $care && $sorttype . $sortdirection !== $this->lastsubalbumsort) {
            if (is_null($sorttype)) {
                $sorttype = $this->getSortType('album');
            }
            if (is_null($sortdirection)) {
                if ($this->getSortDirection('album')) {
                    $sortdirection = 'DESC';
                } else {
                    $sortdirection = '';
                }
            }
            $searchengine = $this->getSearchEngine();
            $subalbums = $searchengine->getAlbums(0, $sorttype, $sortdirection, $care, $mine);
            $key = $this->getAlbumSortKey($sorttype);
            $this->subalbums = $_zp_gallery->sortAlbumArray($this, $subalbums, $key, $sortdirection, $mine);
            $this->lastsubalbumsort = $sorttype . $sortdirection;
        }
        return parent::getAlbums($page);
    }

    /**
     * Returns the search parameters for a dynamic album
     *
     * @return string
     */
    function getSearchParams() {
        return $this->get('search_params');
    }

    /**
     * Sets the search parameters of a dynamic album
     *
     * @param string $params The search string to produce the dynamic album
     */
    function setSearchParams($params) {
        $this->set('search_params', $params);
    }

    /**
     * Returns the search engine for a dynamic album
     *
     * @return object
     */
    function getSearchEngine() {
        if (!is_null($this->searchengine))
            return $this->searchengine;
        $this->searchengine = new SearchEngine(true);
        $params = $this->get('search_params');
        $params .= '&albumname=' . $this->name;
        $this->searchengine->setSearchParams($params);
        return $this->searchengine;
    }

    /**
     * Returns a of a slice of the images for this album. They will
     * also be sorted according to the sort type of this album, or by filename if none
     * has been set.
     *
     * @param int $page  Which page of images should be returned. If zero, all images are returned.
     * @param int $firstPageCount count of images that go on the album/image transition page
     * @param string $sorttype optional sort type
     * @param string $sortdirection optional sort direction
     * @param bool $care set to false if the order of the images does not matter
     * @param bool $mine set true/false to override ownership
     *
     * @return array
     */
    function getImages($page = 0, $firstPageCount = 0, $sorttype = null, $sortdirection = null, $care = true, $mine = NULL) {
        if (!$this->exists)
            return array();
        if ($mine || is_null($this->images) || $care && $sorttype . $sortdirection !== $this->lastimagesort) {
            if (is_null($sorttype)) {
                $sorttype = $this->getSortType();
            }
            if (is_null($sortdirection)) {
                if ($this->getSortDirection('image')) {
                    $sortdirection = 'DESC';
                }
            }
            $searchengine = $this->getSearchEngine();
            $this->images = $searchengine->getImages(0, 0, $sorttype, $sortdirection, $care, $mine);
            $this->lastimagesort = $sorttype . $sortdirection;
        }
        return parent::getImages($page, $firstPageCount);
    }

    /**
     * Delete the entire album PERMANENTLY. Be careful! This is unrecoverable.
     * Returns true if successful
     *
     * @return bool
     */
    function remove() {
        if ($rslt = parent::remove()) {
            @chmod($this->localpath, 0777);
            $rslt = @unlink($this->localpath);
            clearstatcache();
        }
        return $rslt;
    }

    /**
     * Move this album to the location specified by $newfolder, copying all
     * metadata, subalbums, and subalbums' metadata with it.
     * @param $newfolder string the folder to move to, including the name of the current folder (possibly renamed).
     * @return int 0 on success and error indicator on failure.
     *
     */
    function move($newfolder,$oldfolder="") {
        return $this->_move($newfolder);
    }

    protected function succeed($dest) {
        return @copy($this->localpath, $dest);
    }

    /**
     * Copy this album to the location specified by $newfolder, copying all
     * metadata, subalbums, and subalbums' metadata with it.
     * @param $newfolder string the folder to copy to, including the name of the current folder (possibly renamed).
     * @return int 0 on success and error indicator on failure.
     *
     */
    function copy($newfolder) {
        return parent::copy($newfolder);
    }

    /**
     * Simply creates objects of all the images and sub-albums in this album to
     * load accurate values into the database.
     */
    function preLoad() {
        return; // nothing to do
    }

    protected function loadFileNames($dirs = false) {
        return array();
    }

    function isDynamic() {
        return 'alb';
    }
    
    /**
     * Sets default values for a new album
     *
     * @return bool
     */
    protected function setDefaults() {
        global $_zp_gallery;
        // Set default data for a new Album (title and parent_id)
        parent::setDefaults();
        $parentalbum = $this->getParent();
        $this->set('mtime', filemtime($this->localpath));
        if (!$_zp_gallery->getAlbumUseImagedate()) {
            $this->setDateTime(strftime('%Y-%m-%d %H:%M:%S', $this->get('mtime')));
        }
        $title = trim($this->name);
        if (!is_null($parentalbum)) {
            $this->set('parentid', $parentalbum->getID());
            $title = substr($title, strrpos($title, '/') + 1);
        }
        $this->set('title', sanitize($title, 2));
        return true;
    }

}

?>