Questione : Come posso modificare il modulo di commento di Drupal in modo che non comprenda un campo del homepage?

Ricerca del senso cambiare il campo di commento in Drupal in modo che non chieda il homepage dell'utente.  Ho studiato la possibilità semplicemente di commentare fuori la definizione del homepage nel PHP del modulo, ma dato il numero delle funzioni a cui questo allineamento è legato, ho calcolato che avrebbe causato un mazzo di errori giù la linea.  Che cosa è il migliore senso fare questo? lo scopo finale del

The è di evitare il hyperlinking alle pagine off-site e la forma attualmente è regolata per collegare i dati digitati nel campo del homepage.  Se è più facile da programmare semplicemente il modulo per non generare un hyperlink contro non esposizione il campo affatto, spiegare prego come fare this.

I hanno inviato sotto il centro comment.module e lime di comment.js dal Drupal 6.6 install.

What è il migliore senso avvicinarsi a questo?

Thanks! class= > " libero " del
> " del codeSnippet " del class= del
class= " lineNumbers " del
class= del 
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:
1964:
1965:
1966:
1967:
1968:
1969:
1970:
1971:
1972:
1973:
1974:
1975:
1976:
1977:
1978:
1979:
1980:
1981:
1982:
1983:
1984:
1985:
1986:
1987:
1988:
1989:
1990:
1991:
1992:
1993:
1994:
1995:
1996:
1997:
1998:
1999:
2000:
2001:
2002:
2003:
2004:
2005:
2006:
2007:
2008:
2009:
2010:
2011:
2012:
2013:
2014:
2015:
2016:
2017:
2018:
2019:
2020:
2021:
2022:
2023:
2024:
2025:
2026:
2027:
2028:
2029:
2030:
2031:
2032:
2033:
2034:
2035:
2036:
2037:
2038:
2039:
2040:
2041:
2042:
2043:
2044:
2045:
2046:
2047:
2048:
2049:
2050:
2051:
2052:
2053:
2054:
2055:
2056:
2057:
2058:
2059:
2060:
2061:
2062:
2063:
2064:
2065:
2066:
2067:
2068:
2069:
2070:
2071:
2072:
2073:
2074:
2075:
2076:
2077:
2078:
2079:
2080:
2081:
2082:
2083:
2084:
2085:
2086:
2087:
2088:
2089:
2090:
2091:
2092:
2093:
2094:
2095:
2096:
2097:
2098:
2099:
2100:
2101:
2102:
2103:
2104:
2105:
>< notpretty " del class= " del id= " codeSnippet651343 del 
„. t (“il modulo di commento permette che gli ospiti commentino i vostri alberini, generanti i bordi ad-hoc di discussione. Qualsiasi href= " il @content-type " type >content di  del Default fissato a Read/Write per permettere che le osservazioni, o Disabled, impedicano le osservazioni. Le regolazioni dell'esposizione di commento ed altri comandi possono anche essere adattati per ogni tipo soddisfatto (alcune regolazioni dell'esposizione sono personalizzabili dai diversi utenti). „, allineamento (“@content-type„ URL del => (“admin/soddisfare/tipi "))). “
„;
      $output. = “
„. t (“i permessi di commento sono assegnati ai ruoli di utente e sono usati per determinare se agli utenti anonimi (o altri ruoli) sono permessi commentare gli alberini. Se agli utenti anonimi sono permessi commentare, le loro informazioni di contatto specifiche possono essere mantenute in biscotti immagazzinati sul loro calcolatore locale per uso nelle presentazioni successive di commento. Quando un commento non ha risposte, può (facoltativamente) essere pubblicato dal relativo autore. Il modulo di commento usa le stesse disposizioni dell'input e le modifiche del HTML disponibili quando genera altre forme di content."). “
„;
      $output. = “
„. t (“per più informazioni, vedere l'entrata in linea del manuale per il >Comment module " di @comment " del href= di  'http://drupal.org/handbook/modules/comment/')). “
„;
      $output di ritorno;
    caso “admin/soddisfare/commento„:
      restituire “il 
„. t (“sotto è una lista di ultime osservazioni inviate al vostro luogo. Scattare sopra la a conforme al vedono il commento, il nome dell'autore per pubblicare le informazioni di utente dell'autore, “pubblicare„ per modificare il testo e “la cancellazione„ per rimuovere il loro submission."). “
„;
    caso “admin/soddisfare/commento/approvazione„:
      restituire “il 
„. t (“sotto è una lista delle osservazioni inviata al vostro luogo che hanno bisogno dell'approvazione. Per approvare un commento, scattar sopra “pubblicano„ ed allora cambiano la relativa “condizione di moderazione„ ad approvato. Scattare sopra la a conforme al vedono il commento, il nome dell'autore per pubblicare le informazioni di utente dell'autore, “pubblicare„ per modificare il testo e “la cancellazione„ per rimuovere il loro submission."). “
„;
  }
}

/**
 * Esecuzione di hook_theme ().
 */
comment_theme di funzione () {
  allineamento di ritorno (
    allineamento del => “del comment_block„ (
      allineamento del => “di discussioni„ (),
    ),
    allineamento del => “del comment_admin_overview„ (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “della forma„),
    ),
    allineamento del => “del comment_preview„ (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “di commento„, POSIZIONE DI SEGNALE MINIMO del => “di nodo„, allineamento del => “di collegamenti„ (), => “visibile„ 1),
    ),
    allineamento del => “del comment_view„ (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “di commento„, POSIZIONE DI SEGNALE MINIMO del => “di nodo„, allineamento del => “di collegamenti„ (), => “visibile„ 1),
    ),
    allineamento del => “dei comment_controls„ (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “della forma„),
    ),
    allineamento del => “di commento„ (
      => “commento„ “della mascherina„,
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “di commento„, POSIZIONE DI SEGNALE MINIMO del => “di nodo„, allineamento del => “di collegamenti„ ()),
    ),
    “comment_folded„ l'allineamento del => (
      „ => ““della mascherina commentare-piegato„,
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “di commento„),
    ),
    “comment_flat_collapsed„ l'allineamento del => (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => di POSIZIONE DI SEGNALE MINIMO, “di nodo„ del => “di commento„),
    ),
    “comment_flat_expanded„ l'allineamento del => (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => di POSIZIONE DI SEGNALE MINIMO, “di nodo„ del => “di commento„),
    ),
    “comment_thread_collapsed„ l'allineamento del => (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => di POSIZIONE DI SEGNALE MINIMO, “di nodo„ del => “di commento„),
    ),
    “comment_thread_expanded„ l'allineamento del => (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => di POSIZIONE DI SEGNALE MINIMO, “di nodo„ del => “di commento„),
    ),
    “comment_post_forbidden„ l'allineamento del => (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “del nid„),
    ),
    allineamento del => “del comment_wrapper„ (
      => “commentare-involucro„ “della mascherina„,
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => di POSIZIONE DI SEGNALE MINIMO, “di nodo„ del => “del soddisfare„),
    ),
    “comment_submitted„ l'allineamento del => (
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “di commento„),
    ),
  );
}

/**
 * Esecuzione del hook_menu ().
 */
comment_menu di funzione () {
  $items [“admin/soddisfare/commento„] = allineamento (
    „ il => ““di titolo commenta„,
    la lista„ del => ““di descrizione e pubblica le osservazioni del luogo e la coda di moderazione di commento. „,
    “paginare => “comment_admin„ di chiamata ripetuta„,
    “accedere alle discussioni„ allineamento del => (“amministrare le osservazioni "),
    “archivare„ il => “comment.admin.inc„,
  );

  Linguette di //:
  $items [“admin/soddisfare/commento/nuovo„] = allineamento (
    => “osservazioni pubblicate„ “di titolo„,
    “scriv„ il => a macchina MENU_DEFAULT_LOCAL_TASK,
    “appesantire„ il => -10,
  );
  $items [“admin/soddisfare/commento/approvazione„] = allineamento (
    “intitolare„ il => “coda di approvazione„,
    “paginare le discussioni„ l'allineamento del => (“approvazione "),
    “accedere alle discussioni„ allineamento del => (“amministrare le osservazioni "),
    “scriv„ il => a macchina MENU_LOCAL_TASK,
    “archivare„ il => “comment.admin.inc„,
  );

  $items [“commento/cancellazione„] = allineamento (
    => “commento “di titolo„ di cancellazione„,
    “paginare => “comment_delete„ di chiamata ripetuta„,
    “accedere alle discussioni„ allineamento del => (“amministrare le osservazioni "),
    “scriv„ il => a macchina MENU_CALLBACK,
    “archivare„ il => “comment.admin.inc„,
  );

  $items [“il commento/pubblica„] = allineamento (
    „ il => ““di titolo pubblica il commento„,
    “paginare => “comment_edit„ di chiamata ripetuta„,
    “accedere alle discussioni„ l'allineamento del => (“osservazioni dell'alberino "),
    “scriv„ il => a macchina MENU_CALLBACK,
    “archivare„ il => “comment.pages.inc„,
  );
  $items [“commento/reply/%node„] = allineamento (
    => “risposta “di titolo„ al commento„,
    “paginare„ => “di chiamata ripetuta comment_reply„,
    “paginare allineamento del => di discussioni„ (2),
    “accedere => “node_access„ a chiamata ripetuta„,
    “accedere allineamento del => a discussioni„ (“vista„, 2),
    “scriv„ il => a macchina MENU_CALLBACK,
    “archivare„ il => “comment.pages.inc„,
  );

  $items di ritorno;
}

/**
 * Esecuzione di hook_node_type ().
 */
comment_node_type di funzione ($op, $info) {
  $settings = allineamento (
    “commento„,
    “comment_default_mode„,
    “comment_default_order„,
    “comment_default_per_page„,
    “comment_controls„,
    “comment_anonymous„,
    “comment_subject_field„,
    “comment_preview„,
    “comment_form_location„,
  );
  commutare ($op) {
    mettere “la cancellazione„:
      foreach ($settings come $setting) {
        variable_del ($setting. “_„. $info->type);
      }
      rottura;
  }
}

/**
 * Esecuzione di hook_perm ().
 */
comment_perm di funzione () {
  allineamento di ritorno (“l'accesso commenta„, “alberino commenta„, “amministra le osservazioni„, “le osservazioni dell'alberino senza approvazione ");
}

/**
 * Esecuzione di hook_block ().
 *
 * Genera un blocco con le osservazioni più recenti.
 */
comment_block di funzione ($op = “lista„, $delta = 0) {
  se (lista del == di $op “") {
    $blocks [0] [“Info„] = t (“osservazioni recenti ");
    $blocks di ritorno;
  }
  altrimenti se (user_access del && “di vista„ del == di $op (“osservazioni di accesso ")) {
    $block [“oggetto„] = t (“osservazioni recenti ");
    $block [“soddisfare„] = tema (“comment_block ");
    $block di ritorno;
  }
}

/**
 * Trovare un certo numero di osservazioni recenti. Ciò è fatta a due punti.
 * 1. trova i nodi di n (specificata da $number) che hanno il più recente
 * osservazioni.  Ciò è fatta dal node_comment_statistics d'interrogazione che ha
 * un indice su last_comment_timestamp ed è così una domanda veloce.
 * 2. che caricano le informazioni dalla tabella di osservazioni basata sui nids hanno trovato
 * a punto 1.
 *
 * @param $number
 * (facoltativo) il numero massimo delle osservazioni da trovare.
 * @return
 * Un allineamento del commento obietta ciascuno che contiene un nid,
 * oggetto, cid e timestamp, o un allineamento vuoto se non ci è recente
 * osservazioni visibili all'utente corrente.
 */
funzione comment_get_recent ($number = 10) {
  // seleziona i nodi di $number (visibili all'utente corrente) con più
  osservazioni recenti di //. Ciò è efficiente dovuto l'indice sopra
  last_comment_timestamp di //.
  $result = db_query_range (db_rewrite_sql (“nc.nid PRESCELTO {node_comment_statistics} dal nc DOVE ment_count di nc.com > 0 ORDINI da nc.last_comment_timestamp DESC„, “dal nc "), 0, $number);

  $nids = allineamento ();
  mentre ($row = db_fetch_object ($result)) {
    $nids [] = $row->nid;
  }

  $comments = allineamento ();
  se (! svuotare ($nids)) {
    // fra dalle osservazioni sui nodi selezionati nella prima domanda,
    // trova le osservazioni più recenti di $number.
    $result = db_query_range (“c.nid PRESCELTI, c.subject, c.cid, c.timestamp {osservazioni} dalla c INTERNA UNISCONO {nodo} la n SU n.nid = c.nid DOVE c.nid DENTRO (". implode (“,„, $nids) .") E n.status = 1 ED ORDINE di %d = di c.status da c.cid DESC„, DA COMMENT_PUBLISHED, 0, $number);
    mentre ($comment = db_fetch_object ($result)) {
      $comments [] = $comment;
    }
  }

  $comments di ritorno;
}

/**
 * Calcolare il numero di pagina per il primo nuovo commento.
 *
 * @param $num_comments
 * Numero delle osservazioni.
 * @param $new_replies
 * Numero di nuove risposte.
 * @param $node
 * Il primo nuovo nodo di commento.
 * @return
 * “page=X„ se il numero di pagina è maggior di zero; stringa vuota al contrario.
 */
comment_new_page_count di funzione ($num_comments, $new_replies, $node) {
  $comments_per_page = _comment_get_display_setting (“comments_per_page„, $node);
  $mode = _comment_get_display_setting (“modo„, $node);
  $order = _comment_get_display_setting (“specie„, $node);
  $pagenum = POSIZIONE DI SEGNALE MINIMO;
  $flat = in_array ($mode, allineamento (COMMENT_MODE_FLAT_COLLAPSED, COMMENT_MODE_FLAT_EXPANDED));
  se (<= $comments_per_page di $num_comments || (== COMMENT_ORDER_NEWEST_FIRST del && $order di $flat)) {
    // soltanto una pagina delle osservazioni o del prime piano più nuovo e del tribuna.
    Il nuovo commento di // in primo luogo sarà sempre alla prima pagina.
    $pageno = 0;
  }
  altrimenti {
    se ($flat) {
      Osservazioni del piano di // ed il più vecchio prime.
      $count = $num_comments - $new_replies;
    }
    altrimenti {
      // ha filettato le osservazioni. Vedere la documentazione per comment_render ().
      se (== COMMENT_ORDER_NEWEST_FIRST di $order) {
        Il più nuovo primo di //: trovare l'ultimo filetto con il nuovo commento
        $result = db_query (“(filetto PRESCELTO DA {osservazioni} DOVE nid = %d E condizione = 0 ORDINI DA ORDINE di LIMITE del timestamp DESC %d) DAL LIMITE 1„, $node->nid, $new_replies del filetto DESC);
        $thread = db_result ($result);
        $result_count = db_query (“CONTEGGIO PRESCELTO (*) DA {osservazioni} DOVE nid = %d E condizione = 0 E filetto > “„. $thread. “„ “, $node->nid);
      }
      altrimenti {
        Il più vecchio primo di //: trovare il primo filetto con il nuovo commento
        LIMITE 1„, $node->nid, $new_replies di db_query = di $result (“(filetto PRESCELTO DA {osservazioni} DOVE nid = %d E condizione = 0 ORDINI DA ORDINE di LIMITE del timestamp DESC %d) DA SUBSTRING (filetto, 1, (LUNGHEZZA (filetto) - 1)));
        $thread = substr (db_result ($result), 0, -1);
        $result_count = db_query (“CONTEGGIO PRESCELTO (*) DA {osservazioni} DOVE nid = %d E condizione = 0 E SOTTOSTRINGA (filetto, 1, (LUNGHEZZA (filetto) - 1)) < “„. $thread. “„ “, $node->nid);
      }
      $count = db_result ($result_count);
    }
    $pageno = $count/$comments_per_page;
  }
  se (>= di $pageno 1) {
    $pagenum = “page=„. intval ($pageno);
  }
  $pagenum di ritorno;
}

/**
 * Restituisce una lista formattata delle osservazioni recenti da visualizzare nel blocchetto di commento.
 *
 * @return
 * Il HTML della lista di commento.
 * @ingroup themeable
 */
theme_comment_block di funzione () {
  $items = allineamento ();
  foreach (comment_get_recent () come $comment) {
    $items [] = l ($comment->subject, “nodo„. $comment->nid, allineamento (=> “commento„ “del frammento„. $comment->cid)). “
„. t (“@time fa„, allineamento (=> “del @time„ format_interval (tempo () - $comment->timestamp)));
  }
  se ($items) {
    tema di ritorno (“item_list„, $items);
  }
}

/**
 * Esecuzione di hook_link ().
 */
comment_link di funzione ($type, $node = POSIZIONE DI SEGNALE MINIMO, $teaser = FALSO) {
  $links = allineamento ();

  se (&& $node->comment “di nodo„ del == di $type) {

    se ($teaser) {
      Pagina principale di //: visualizzare il numero delle osservazioni che sono state inviate.

      se (user_access (“osservazioni di accesso ")) {
        $all = comment_num_all ($node->nid);

        se ($all) {
          $links [“comment_comments„] = allineamento (
            “titolo„ => format_plural ($all, “1 commento„, “osservazioni del @count "),
            => “node/$node->nid„ “del href„,
            “attribuisce„ l'allineamento del => (“titolo„ => t (“salto al primo commento di questo posting.")),
            „ il => ““del frammento commenta„
          );

          $new = comment_num_new ($node->nid);

          se ($new) {
            $links [“comment_new_comments„] = allineamento (
              “titolo„ => format_plural ($new, “1 nuovo commento„, “osservazioni del @count nuove "),
              => “node/$node->nid„ “del href„,
              comment_new_page_count del => “di domanda„ ($all, $new, $node),
              “attribuisce„ l'allineamento del => (“titolo„ => t (“salto al primo nuovo commento di questo posting.")),
              „ => ““del frammento nuovo„
            );
          }
        }
        altrimenti {
          se (== COMMENT_NODE_READ_WRITE di $node->comment) {
            se (user_access (“osservazioni dell'alberino ")) {
              $links [“comment_add„] = allineamento (
                “titolo„ => t (“aggiungere il nuovo commento "),
                => “commento/reply/$node->nid„ “del href„,
                “attribuisce„ l'allineamento del => (“titolo„ => t (“aggiungere un nuovo commento a questo page.")),
                “spezzettare„ il => “commentare-forma„
              );
            }
            altrimenti {
              $links [“comment_forbidden„] [“titolo„] = tema (“comment_post_forbidden„, $node);
            }
          }
        }
      }
    }
    altrimenti {
      Pagina di nodo di //: aggiungere “un collegamento di commento dell'alberino„ se all'utente è permesso a
      l'alberino di // commenta, se questo nodo non è passivo e se la forma di commento già non è indicata

      se (== COMMENT_NODE_READ_WRITE di $node->comment) {
        se (user_access (“osservazioni dell'alberino ")) {
          se (variable_get (“comment_form_location_„. $NODE->TYPE, == COMMENT_FORM_SEPARATE_PAGE DI COMMENT_FORM_SEPARATE_PAGE)) {
            $links [“comment_add„] = allineamento (
              “titolo„ => t (“aggiungere il nuovo commento "),
              => “commento/reply/$node->nid„ “del href„,
              “attribuisce„ l'allineamento del => (“titolo„ => t (“ripartire i vostri pensieri e pareri relativi a questo posting.")),
              “spezzettare„ il => “commentare-forma„
            );
          }
        }
        altrimenti {
          $links [“comment_forbidden„] [“titolo„] = tema (“comment_post_forbidden„, $node);
        }
      }
    }
  }

  se (commento del == di $type “") {
    $links = comment_links ($node, $teaser);
  }
  se (isset ($links [“comment_forbidden„])) {
    $links [“comment_forbidden„] [“HTML„] = ALLINEANO;
  }

  restituire $links;
}

/**
 * Esecuzione di hook_form_alter ().
 */
comment_form_alter di funzione (&$form, $form_state, $form_id) {
  se (isset del && “del node_type_form„ del == di $form_id ($form [“identità„] [“tipo„])) {
    $form [“commento„] = allineamento (
      => “fieldset„ “del #type„,
      “#title„ => t (“regolazioni di commento "),
      => “#collapsible„ ALLINEARE,
      => “#collapsed„ ALLINEARE,
    );
    $form [“commento„] [“commento„] = allineamento (
      „ il => ““del #type radiotrasmette„,
      “#title„ => t (“regolazione di commento di difetto "),
      variable_get del => “del #default_value„ (“comment_„. >type di $form [“#node_type„] -, COMMENT_NODE_READ_WRITE),
      allineamento del => “di #options„ (t (“ha reso invalido "), t (“colto soltanto "), t (“Read/Write ")),
      “#description„ => t (“gli utenti con il permesso del administer comments potranno ignorare questo setting."),
    );
    $form [“commento„] [“comment_default_mode„] = allineamento (
      „ il => ““del #type radiotrasmette„,
      “#title„ => t (“modo di esposizione di difetto "),
      variable_get del => “del #default_value„ (“comment_default_mode_„. >type di $form [“#node_type„] -, COMMENT_MODE_THREADED_EXPANDED),
      _comment_get_modes del => “di #options„ (),
      “#description„ => t (“la vista di difetto per le osservazioni. Le viste ampliate visualizzano il corpo del commento. Le viste filettate mantengono le risposte together."),
    );
    $form [“commento„] [“comment_default_order„] = allineamento (
      „ il => ““del #type radiotrasmette„,
      “#title„ => t (“ordine dell'esposizione di difetto "),
      variable_get del => “del #default_value„ (“comment_default_order_„. >type di $form [“#node_type„] -, COMMENT_ORDER_NEWEST_FIRST),
      _comment_get_orders del => “di #options„ (),
      “#description„ => t (“il difetto che fascicola per i nuovi utenti e gli utenti anonimi mentre osservano commenta. Questi utenti possono cambiare il loro punto di vista using il quadro di controllo di commento. Per gli utenti registrati, questo cambiamento è ricordato come utente persistente preference."),
    );
    $form [“commento„] [“comment_default_per_page„] = allineamento (
      „ il => ““del #type seleziona„,
      “#title„ => t (“il difetto commenta per pagina "),
      variable_get del => “del #default_value„ (“comment_default_per_page_„. >type di $form [“#node_type„] -, 50),
      _comment_per_page del => “di #options„ (),
      “#description„ => t (“numero di difetto delle osservazioni per ogni pagina: più osservazioni si distribuiscono da parecchio pages."),
    );
    $form [“commento„] [“comment_controls„] = allineamento (
      „ il => ““del #type radiotrasmette„,
      “#title„ => t (“comandi di commento "),
      variable_get del => “del #default_value„ (“comment_controls_„. >type di $form [“#node_type„] -, COMMENT_CONTROLS_HIDDEN),
      allineamento del => “di #options„ (
        t (“esposizione sopra le osservazioni "),
        t (“esposizione sotto le osservazioni "),
        t (“esposizione sopra e sotto le osservazioni "),
        t (“non fa l'esposizione ")),
      “#description„ => t (“posizione della cassetta di controllo di commento. I comandi di commento hanno lasciato l'utente cambiare il modo di esposizione di difetto e visualizzare un ordine di comments."),
    );
    $form [“commento„] [“comment_anonymous„] = allineamento (
      „ il => ““del #type radiotrasmette„,
      “#title„ => t (“commento anonimo "),
      variable_get del => “del #default_value„ (“comment_anonymous_„. >type di $form [“#node_type„] -, COMMENT_ANONYMOUS_MAYNOT_CONTACT),
      allineamento del => “di #options„ (
        => t di COMMENT_ANONYMOUS_MAYNOT_CONTACT (“i manifesti anonimi non possono entrare nelle loro informazioni di contatto "),
        => t di COMMENT_ANONYMOUS_MAY_CONTACT (“i manifesti anonimi possono lasciare le loro informazioni di contatto "),
        => t di COMMENT_ANONYMOUS_MUST_CONTACT (“i manifesti anonimi devono lasciare le loro informazioni di contatto ")),
      “#description„ => t (“questa opzione è permessa a quando gli utenti anonimi hanno permesso inviare le osservazioni sui >permissions page " del @url " del href= di  (“admin/utente/permessi„, allineamento („ il => ““del frammento modulo-commenta ")))),
    );
    se (! user_access (“l'alberino commenta„, il drupal_anonymous_user ())) {
      $form [“commento„] [“comment_anonymous„] [“#disabled„] = ALLINEARE;
    }
    $form [“commento„] [“comment_subject_field„] = allineamento (
      „ il => ““del #type radiotrasmette„,
      “#title„ => t (“argomento di commento "),
      variable_get del => “del #default_value„ (“comment_subject_field_„. >type di $form [“#node_type„] -, 1),
      allineamento del => “di #options„ (t (“ha reso invalido "), t (“permesso a ")),
      “#description„ => t (“possono gli utenti fornire un oggetto unico per le loro osservazioni? "),
    );
    $form [“commento„] [“comment_preview„] = allineamento (
      „ il => ““del #type radiotrasmette„,
      “#title„ => t (“commento di previsione "),
      variable_get del => “del #default_value„ (“comment_preview_„. >type di $form [“#node_type„] -, COMMENT_PREVIEW_REQUIRED),
      allineamento del => “di #options„ (t (“facoltativo "), t (“ha richiesto ")),
      => t (“forze “di #description„ un utente per esaminare il loro commento scattandosi “su una previsione„ tasto prima che possano realmente aggiungere il commento„),
    );
    $form [“commento„] [“comment_form_location„] = allineamento (
      „ il => ““del #type radiotrasmette„,
      “#title„ => t (“posizione della forma di presentazione di commento "),
      variable_get del => “del #default_value„ (“comment_form_location_„. >type di $form [“#node_type„] -, COMMENT_FORM_SEPARATE_PAGE),
      allineamento del => “di #options„ (t (“esposizione alla pagina separata "), t (“esposizione sotto l'alberino o le osservazioni ")),
    );
  }
  isset del && del elseif (isset ($form [“tipo„]) ($form [“#node„])) {
    se ($form [“tipo„] [“#value„]. == $form_id “del _node_form„) {
      $node = $form [“#node„];
      $form [“comment_settings„] = allineamento (
        => “fieldset„ “del #type„,
        “#access„ user_access del => (“amministrare le osservazioni "),
        “#title„ => t (“regolazioni di commento "),
        => “#collapsible„ ALLINEARE,
        => “#collapsed„ ALLINEARE,
        => 30 “del #weight„,
      );
      $form [“comment_settings„] [“commento„] = allineamento (
        „ il => ““del #type radiotrasmette„,
        “#parents„ allineamento del => (“commento "),
        => $node->comment “del #default_value„,
        allineamento del => “di #options„ (t (“ha reso invalido "), t (“colto soltanto "), t (“Read/Write ")),
      );
    }
  }
}

/**
 * Esecuzione del hook_nodeapi ().
 */
comment_nodeapi di funzione (&$node, $op, $arg = 0) {
  commutare ($op) {
    mettere “il carico„:
      restituire db_fetch_array (db_query (“last_comment_timestamp PRESCELTO, last_comment_name, comment_count DA {node_comment_statistics} DOVE nid = %d„, $node->nid));
      rottura;

    il caso “prepara„:
      se (! isset ($node->comment)) {
        $node->comment = variable_get (“comment_$node->type„, COMMENT_NODE_READ_WRITE);
      }
      rottura;

    caso “inserto„:
      db_query (“l'INSERTO IN {node_comment_statistics} (nid, last_comment_timestamp, last_comment_name, last_comment_uid, comment_count) STIMA (%d, %d, POSIZIONE DI SEGNALE MINIMO, %d, 0)„, $node->nid, $node->changed, $node->uid);
      rottura;

    caso “cancellazione„:
      db_query (“CANCELLAZIONE DA {osservazioni} DOVE nid = %d„, $node->nid);
      db_query (“CANCELLAZIONE DA {node_comment_statistics} DOVE nid = %d„, $node->nid);
      rottura;

    caso “indice dell'aggiornamento„:
      $text = '';
      $comments = db_query (“oggetto PRESCELTO, commento, disposizione DA {osservazioni} DOVE nid = %d E condizione = %d„, $node->nid, COMMENT_PUBLISHED);
      mentre ($comment = db_fetch_object ($comments)) {
        $text. = “
„. check_plain ($comment->subject). “
„. check_markup ($comment->comment, $comment->format, FALSI);
      }
      $text di ritorno;

    caso “risultato di ricerca„:
      $comments = db_result (db_query (“comment_count PRESCELTO DA {node_comment_statistics} DOVE nid = %d„, $node->nid));
      format_plural di ritorno ($comments, “1 commento„, “osservazioni del @count ");

    caso “elemento dei rss„:
      se ($node->comment! = COMMENT_NODE_DISABLED) {
        allineamento di ritorno (allineamento (il URL del => “di valore„„ del => ““di chiave commenta„, (“nodo„. $node->nid, allineamento („ il => ““del frammento commenta„, => “assoluto„ ALLINEARE))));
      }
      altrimenti {
        allineamento di ritorno ();
      }
  }
}

/**
 * Esecuzione di hook_user ().
 */
comment_user di funzione ($type, $edit, &$user, $category = POSIZIONE DI SEGNALE MINIMO) {
  se (cancellazione del == di $type “") {
    db_query (“l'AGGIORNAMENTO {osservazioni} HA REGOLATO il uid = 0 DOVE uid = %d„, $user->uid);
    db_query (“l'AGGIORNAMENTO {node_comment_statistics} HA REGOLATO il last_comment_uid = 0 DOVE last_comment_uid = %d„, $user->uid);
  }
}

/**
 * Ciò è *not* un l'esecuzione dei hook_access (). Questa funzione è denominata
 * per determinare se l'utente corrente ha accesso ad un commento particolare.
 *
 * Gli utenti autenticati possono pubblicare le loro osservazioni poichè lungamente non sono stati
 * risposto a. Ciò impedisce alla gente di cambiare o di modificare loro
 * dichiarazioni basate sulle risposte ai loro alberini.
 *
 * @param $op
 * Il funzionamento che deve essere effettuato sul commento. “Pubblicare soltanto„ è riconosciuto ora.
 * @param $comment
 * L'oggetto di commento.
 * @return
 * ALLINEARE se l'utente corrente ha acces al commento, FALSO al contrario.
 */
comment_access di funzione ($op, $comment) {
  $user globale;

  se (il == di $op “pubblica ") {
    rinviare (== 0 dei comment_num_replies del && del == $comment->uid del && $user->uid di $user->uid ($comment->cid)) || user_access (“amministrare le osservazioni ");
  }
}

/**
 * Una funzione semplice dell'assistente.
 *
 * @return
 * Le 0th e prime componenti del percorso si sono unite da un taglio.
 */
comment_node_url di funzione () {
  arg di ritorno (0). “/„. arg (1);
}

/**
 * Accetta una presentazione di nuovo o soddisfare variabile di commento.
 *
 * @param $edit
 * Un allineamento di commento.
 *
 * @return
 * Se il commento è conservato con successo l'identificazione di commento è restituita. Se il commento
 * non è conservato, FALSO è rinviato.
 */
comment_save di funzione ($edit) {
  $user globale;
  se (&& dei user_access (“osservazioni dell'alberino ") (user_access (“amministrare le osservazioni ") || == COMMENT_NODE_READ_WRITE del node_comment_mode ($edit [“nid„]))) {
    se (! form_get_errors ()) {
      allineamento di $edit += (
        “posta„ => '',
        “homepage„ => '',
        “nome„ => '',
        “condizione„ user_access del => (“l'alberino commenta senza approvazione ")? COMMENT_PUBLISHED: COMMENT_NOT_PUBLISHED,
      );
      se ($edit [“cid„]) {
        Aggiornamento di // il commento nella base di dati.
        db_query (“l'AGGIORNAMENTO {osservazioni} HA REGOLATO la condizione = %d, timestamp = %d, oggetto = “%s„, commento = “%s„, disposizione = %d, uid = %d, nome = “%s„, posta = “%s„, homepage = “%s„ DOVE cid = %d„, $edit [“condizione„], $edit [“timestamp„], $edit [“oggetto„], $edit [“commento„], $edit [“disposizione„], $edit [“uid„], $edit [“nome„], $edit [“posta„], $edit [“homepage„], $edit [“cid„]);

        // permette che i moduli rispondano all'aggiornamento di un commento.
        comment_invoke_comment ($edit, “aggiornamento ");

        // aggiunge un'entrata al ceppo del cane da guardia.
        cane da guardia (“soddisfare„, “commento: %subject aggiornato.  $edit [“nid„], allineamento (=> “commento„ “del frammento„. $edit [“cid„])));
      }
      altrimenti {
        // aggiunge il commento a base di dati.
        // qui stiamo sviluppando il giacimento del filetto. Vedere la documentazione per
        comment_render di // ().
        se (== 0 di $edit [“pid„]) {
          // questo è un commento senza il commento del genitore (profondità 0): cominciamo
          // richiamando il carico massimo del filetto.
          $max = db_result (db_query (“max PRESCELTO (filetto) DA {osservazioni} DOVE nid = %d„, $edit [“nid„]));

          Striscia di // “/„ dall'estremità del filetto.
          $max = rtrim ($max, “/");

          // per concludere, sviluppa il giacimento del filetto per questo nuovo commento.
          $thread = int2vancode (vancode2int ($max) + 1). “/„;
        }
        altrimenti {
          // questo è commento con un commento del genitore: aumentiamo
          // la parte di valore del filetto alla profondità adeguata.

          // ottiene il commento del genitore:
          $parent = _comment_load ($edit [“pid„]);

          Striscia di // “/„ dall'estremità del filetto del genitore.
          $parent->thread = rtrim (della stringa) ((stringa) $parent->thread, “/");

          // ottiene il valore massimo in filetto del _this_.
          $max = db_result (db_query (“max PRESCELTO (filetto) DA {osservazioni} DOVE il filetto GRADICE “%s.%%„ E il nid = %d„, $parent->thread, $edit [“nid„]));

          se (== di $max '') {
            Primo bambino di // di questo genitore.
            $thread = $parent->thread. “.„. int2vancode (0). “/„;
          }
          altrimenti {
            Striscia di // “/„ all'estremità del filetto.
            $max = rtrim ($max, “/");

            // che dobbiamo ottenere il valore alla profondità corretta.
            $parts = esplodono (“. „, $max);
            $parent_depth = conteggio (esplodere (“. „, $parent->thread));
            $last = $parts [$parent_depth];

            // per concludere, sviluppa il giacimento del filetto per questo nuovo commento.
            $thread = $parent->thread. “.„. int2vancode (vancode2int ($last) + 1). “/„;
          }
        }

        se (svuotare ($edit [“timestamp„])) {
          $edit [“timestamp„] = tempo ();
        }

        se (=== $user->uid) {// “===„ di $edit [“uid„] perché vogliamo modificare gli utenti anonimi anche
          $edit [“nome„] = $user->name;
        }

        db_query (“l'INSERTO IN {osservazioni} (nid, pid, uid, oggetto, commento, disposizione, hostname, timestamp, condizione, filetto, nome, posta, homepage) STIMA (%d, %d, %d, “%s„, “%s„, %d, “%s„, %d, %d, “%s„, “%s„, “%s„, “%s ")„, $edit [“nid„], $edit [“pid„], $edit [“uid„], $edit [“oggetto„], $edit [“commento„], $edit [“disposizione„], ip_address (), $edit [“timestamp„], $edit [“condizione„], $thread, $edit [“nome„], $edit [“posta„], $edit [“homepage„]);
        $edit [“cid„] = db_last_insert_id (“osservazioni„, “cid ");

        // dice gli altri moduli che un nuovo commento è stato presentato.
        comment_invoke_comment ($edit, “inserto ");

        // aggiunge un'entrata al ceppo del cane da guardia.
        cane da guardia (“soddisfare„, “commento: %subject aggiunto.  $edit [“nid„], allineamento (=> “commento„ “del frammento„. $edit [“cid„])));
      }
      _comment_update_node_statistics ($edit [“nid„]);

      La radura di // il nascondiglio in modo da un utente anonimo può vedere il suo commento che si è aggiunto.
      cache_clear_all ();

      // se necessario ed allora spiega la coda di approvazione
      // riorienta l'utente al nodo che sta commentando sopra.
      se (== COMMENT_NOT_PUBLISHED di $edit [“condizione„]) {
        drupal_set_message (t (“il vostro commento è stato fatto la coda per la moderazione dai coordinatori del luogo e sarà pubblicato dopo approval."));
      }
      altrimenti {
        comment_invoke_comment ($edit, “pubblicano ");
      }
      $edit di ritorno [“cid„];
    }
    altrimenti {
      FALSO di ritorno;
    }
  }
  altrimenti {
    cane da guardia (“soddisfare„, “commento: il commento non autorizzato ha presentato o commento presentato ad un alberino chiuso %subject. „, allineamento (“%subject„ => $edit [“oggetto„]), WATCHDOG_WARNING);
    drupal_set_message (t (“commento: il commento non autorizzato ha presentato o commento presentato ad un alberino chiuso %subject. , “errore ");
    FALSO di ritorno;
  }
}

/**
 * Collegamenti di ordine di configurazione per un commento (per esempio \ pubblicare, rispondere, cancellazione) riguardo ai permessi di accesso correnti dell'utente.
 *
 * @param $comment
 * Il commento a cui i collegamenti saranno relativi.
 * @param $return
 * Usato.
 * @return
 * Un allineamento associativo che contiene i collegamenti.
 */
comment_links di funzione ($comment, $return = 1) {
  $user globale;

  $links = allineamento ();

  // se stiamo osservando appena questo commento, ci colleghiamo di nuovo al nodo.
  se ($return) {
    $links [“comment_parent„] = allineamento (
      “titolo„ => t (“genitore "),
      comment_node_url del => “del href„ (),
      => “comment-$comment->cid„ “del frammento„
    );
  }

  se (== COMMENT_NODE_READ_WRITE del node_comment_mode ($comment->nid)) {
    se (user_access del && dei user_access (“amministrare le osservazioni ") (“osservazioni dell'alberino ")) {
      $links [“comment_delete„] = allineamento (
        “titolo„ => t (“cancellazione "),
        => “commento/delete/$comment->cid„ “del href„
      );
      $links [“comment_edit„] = allineamento (
        “titolo„ => t (“pubblicare "),
        => “commento/edit/$comment->cid„ “del href„
      );
      $links [“comment_reply„] = allineamento (
        “titolo„ => t (“risposta "),
        => “commento/reply/$comment->nid/$comment->cid„ “del href„
      );
    }
    altrimenti se (user_access (“osservazioni dell'alberino ")) {
      se (comment_access (“pubblicare„, $comment)) {
        $links [“comment_edit„] = allineamento (
          “titolo„ => t (“pubblicare "),
          => “commento/edit/$comment->cid„ “del href„
        );
      }
      $links [“comment_reply„] = allineamento (
        “titolo„ => t (“risposta "),
        => “commento/reply/$comment->nid/$comment->cid„ “del href„
      );
    }
    altrimenti {
      $node = node_load ($comment->nid);
      $links [“comment_forbidden„] [“titolo„] = tema (“comment_post_forbidden„, $node);
    }
  }

  restituire $links;
}

/**
 * Rende le osservazioni.
 *
 * @param $node
 * Il nodo che l'osservazione deve rendere.
 * @param $cid
 *, Soltanto un il commento facoltativo, se dato è reso.
 *
 * Ad esposizione filettata commenta nell'ordine che corretto manteniamo un giacimento “del filetto„
 * ed ordine da quel valore. Questo campo mantiene questi dati dentro
 * un senso che è facile da aggiornare e conveniente usare.
 *
 * Inizio di valore “del filetto„ “a 1„. Se aggiungiamo un bambino (A) a questo commento,
 * gli assegniamo “un filetto„ = “1.1„. Un bambino di (A) avrà “1.1.1„. Dopo
 * il fratello di (A) otterrà “1.2„. Il fratello seguente del genitore di (A) otterrà
 * “2„ e così via.
 *
 * In primo luogo di tutti nota che il giacimento del filetto memorizza la profondità del commento:
 * la profondità 0 sarà “X„, profondità 1 “X.X„, profondità 2 “X.X.X„, ecc.
 *
 * Ora per ottenere la destra d'ordinazione, considerare questo esempio:
 *
 * 1
 * 1.1
 * 1.1.1
 * 1.2
 * 2
 *
 * Se “ORDINIAMO dal filetto il CSA„ otteniamo il risultato di cui sopra e questo è
 * ordine naturale fascicolato entro tempo. Tuttavia, se “ORDINIAMO dal filetto DESC„
 * otteniamo:
 *
 * 2
 * 1.2
 * 1.1.1
 * 1.1
 * 1
 *
 * Chiaramente, questo non è un senso naturale vedere un filetto e gli utenti otterranno
 * confuso. L'ordine naturale per mostrare un filetto dal desc di tempo sarebbe:
 *
 * 2
 * 1
 * 1.2
 * 1.1
 * 1.1.1
 *
 * che è che cosa già abbiamo fatto prima della zona standard dell'impaginatore. Per per realizzare
 * questo aggiungiamo semplicemente “/„ alla conclusione di ogni valore “del filetto„. Questa uscita
 * i giacimenti del filetto assomiglieranno al rappresentato a qui sotto:
 *
 * 1
 * 1.1/
 * 1.1.1/
 * 1.2/
 * 2
 *
 * aggiungiamo “/„ poiché questo carbone è, nell'ASCII, superiore ad ogni numero, così se
 * ora “ORDINIAMO dal filetto DESC„ che otteniamo l'ordine corretto. Tuttavia questo 
 * rovinare l'ordinazione d'inversione, “ORDINE dal filetto il CSA„ -- qui, non abbiamo bisogno di
 * per considerare “di trascinamento/„ così usiamo una sottostringa soltanto.
 */
comment_render di funzione ($node, $cid = 0) {
  $user globale;

  $output = '';

  se (user_access (“osservazioni di accesso ")) {
    // pretratta le variabili.
    $nid = $node->nid;
    se (svuotare ($nid)) {
      $nid = 0;
    }

    $mode = _comment_get_display_setting (“modo„, $node);
    $order = _comment_get_display_setting (“specie„, $node);
    $comments_per_page = _comment_get_display_setting (“comments_per_page„, $node);

    se (&& di $cid is_numeric ($cid)) {
      Singola vista di commento di //.
      $query = “c.cid PRESCELTO, c.pid, c.nid, c.subject, c.com ment, c.format, c.timestamp, c.name, c.mail, c.homepage, u.uid, u.name COME registered_name, u.signature, u.picture, u.data, c.status {osservazioni} dalla c INTERNA UNISCONO {utenti} la u SU c.uid = u.uid DOVE c.cid = %d„;
      $query_args = allineamento ($cid);
      se (! user_access (“amministrare le osservazioni ")) {
        $query. = “E c.status = %d„;
        $query_args [] = COMMENT_PUBLISHED;
      }

      $query = db_rewrite_sql ($query, “c„, “cid ");
      $result = db_query ($query, $query_args);

      se ($comment = db_fetch_object ($result)) {
        $comment->name = $comment->uid? $comment->registered_name: $comment->name;
        $links = module_invoke_all (“collegamento„, “commento„, $comment, 1);
        drupal_alter (“collegamento„, $links, $node);

        $output. = tema (“comment_view„, $comment, $node, $links);
      }
    }
    altrimenti {
      Vista multipla di commento di //
      $query_count = “CONTEGGIO PRESCELTO (*) {osservazioni} dalla c DOVE c.nid = %d„;
      $query = “c.cid PRESCELTO come cid, c.pid, c.nid, c.subject, c.com ment, c.format, c.timestamp, c.name, c.mail, c.homepage, u.uid, u.name COME registered_name, u.signature, u.picture, u.data, c.thread, c.status {osservazioni} dalla c INTERNA UNISCONO {utenti} la u SU c.uid = u.uid DOVE c.nid = %d„;

      $query_args = allineamento ($nid);
      se (! user_access (“amministrare le osservazioni ")) {
        $query. = “E c.status = %d„;
        $query_count. = “E c.status = %d„;
        $query_args [] = COMMENT_PUBLISHED;
      }

      se (== COMMENT_ORDER_NEWEST_FIRST di $order) {
        se (== COMMENT_MODE_FLAT_COLLAPSED di $mode || == COMMENT_MODE_FLAT_EXPANDED di $mode) {
          $query. = “ORDINE da c.cid DESC„;
        }
        altrimenti {
          $query. = “ORDINE da c.thread DESC„;
        }
      }
      altrimenti se (== COMMENT_ORDER_OLDEST_FIRST di $order) {
        se (== COMMENT_MODE_FLAT_COLLAPSED di $mode || == COMMENT_MODE_FLAT_EXPANDED di $mode) {
          $query. = “ORDINE da c.cid„;
        }
        altrimenti {
          // vede il commento qui sopra. L'analisi rivela che questa non costa anche
          // molto. Regola molto molto più meglio dell'avendo il commento di tutto
          struttura di //.
          $query. = “ORDINE DA SUBSTRING (c.thread, 1, (LUNGHEZZA (c.thread) - 1))„;
        }
      }
      $query = db_rewrite_sql ($query, “c„, “cid ");
      $query_count = db_rewrite_sql ($query_count, “c„, “cid ");

      Inizio di // una forma, per uso con controllo di commento.
      $result = pager_query ($query, $comments_per_page, 0, $query_count, $query_args);

      $divs = 0;
      $num_rows = FALSO;
      $comments = '';
      drupal_add_css (drupal_get_path (“modulo„, “commento "). “/comment.css ");
      mentre ($comment = db_fetch_object ($result)) {
        $comment = drupal_unpack ($comment);
        $comment->name = $comment->uid? $comment->registered_name: $comment->name;
        $comment->depth = conteggio (esplodere (“. „, $comment->thread)) - 1;

        se (== COMMENT_MODE_THREADED_COLLAPSED di $mode || == COMMENT_MODE_THREADED_EXPANDED di $mode) {
          se ($comment->depth > $divs) {
            $divs++;
            $comments. = “class= del 
„;
          }
          altrimenti {
            mentre ($comment->depth < $divs) {
              $divs--;
              $comments. = “
„;
            }
          }
        }

        se (== COMMENT_MODE_FLAT_COLLAPSED di $mode) {
          $comments. = tema (“comment_flat_collapsed„, $comment, $node);
        }
        altrimenti se (== COMMENT_MODE_FLAT_EXPANDED di $mode) {
          $comments. = tema (“comment_flat_expanded„, $comment, $node);
        }
        altrimenti se (== COMMENT_MODE_THREADED_COLLAPSED di $mode) {
          $comments. = tema (“comment_thread_collapsed„, $comment, $node);
        }
        altrimenti se (== COMMENT_MODE_THREADED_EXPANDED di $mode) {
          $comments. = tema (“comment_thread_expanded„, $comment, $node);
        }

        $num_rows = ALLINEANO;
      }
      mentre ($divs-- > 0) {
        $comments. = “„;
      }

      $comment_controls = variable_get (“comment_controls_„. $node->type, COMMENT_CONTROLS_HIDDEN);
      se (&& di $num_rows (== COMMENT_CONTROLS_ABOVE di $comment_controls || == COMMENT_CONTROLS_ABOVE_BELOW di $comment_controls)) {
        $output. = drupal_get_form (“comment_controls„, $mode, $order, $comments_per_page);
      }

      $output. = $comments;
      $output. = tema (“impaginatore„, POSIZIONE DI SEGNALE MINIMO, $comments_per_page, 0);

      se (&& di $num_rows (== COMMENT_CONTROLS_BELOW di $comment_controls || == COMMENT_CONTROLS_ABOVE_BELOW di $comment_controls)) {
        $output. = drupal_get_form (“comment_controls„, $mode, $order, $comments_per_page);
      }
    }

    // se permesso a, mostra la nuova forma di commento se già non stia visualizzanda.
    $reply = 0) arg del && “di commento„ del == del arg ((1) == “risposta„;
    se (&& del == COMMENT_NODE_READ_WRITE del node_comment_mode del && dei user_access (“osservazioni dell'alberino ") ($nid) (variable_get (“comment_form_location_„. $NODE->TYPE, && DEL == COMMENT_FORM_BELOW DI COMMENT_FORM_SEPARATE_PAGE))! $reply) {
      $output. = comment_form_box (allineamento (“nid„ => $nid), t (“nuovo commento dell'alberino "));
    }

    $output = tema (“comment_wrapper„, $output, $node);
  }

  $output di ritorno;
}

/**
 * Funzionamenti di commento. Offriamo i funzionamenti differenti dell'aggiornamento secondo
 * che commentano pagina che della gestione siamo sopra.
 *
 * @param $action
 * La pagina della gestione di commento.
 * @return
 * Un allineamento associativo che contiene i funzionamenti offerti.
 */
comment_operations di funzione ($action = POSIZIONE DI SEGNALE MINIMO) {
  se (il == di $action “pubblica ") {
    $operations = allineamento (
      “pubblicare„ l'allineamento del => (t (“pubblicare le osservazioni selezionate "), “AGGIORNAMENTO {osservazioni} HA FISSATO la condizione =„. COMMENT_PUBLISHED. “DOVE cid = %d "),
      “cancellare„ l'allineamento del => (t (“cancellare le osservazioni selezionate "), '')
    );
  }
  altrimenti se (unpublish del == di $action “") {
    $operations = allineamento (
      allineamento del => “del unpublish„ (t (“Unpublish le osservazioni selezionate "), “AGGIORNAMENTO {osservazioni} HA FISSATO la condizione =„. COMMENT_NOT_PUBLISHED. “DOVE cid = %d "),
      “cancellazione„ allineamento del => (t (“cancellare le osservazioni selezionate "), '')
    );
  }
  altrimenti {
    $operations = allineamento (
      “pubblicare„ l'allineamento del => (t (“pubblicare le osservazioni selezionate "), “AGGIORNAMENTO {osservazioni} HA FISSATO la condizione =„. COMMENT_PUBLISHED. “DOVE cid = %d "),
      allineamento del => “del unpublish„ (t (“Unpublish le osservazioni selezionate "), “AGGIORNAMENTO {osservazioni} HA FISSATO la condizione =„. COMMENT_NOT_PUBLISHED. “DOVE cid = %d "),
      “cancellazione„ allineamento del => (t (“cancellare le osservazioni selezionate "), '')
    );
  }
  $operations di ritorno;
}

/**
 * Funzioni varie: assistenti, privates, storia
 */

/**
 * Caricare l'intero commento da cid.
 *
 * @param $cid
 * L'identificazione d'identificazione di commento
 * @return
 * L'oggetto di commento.
 */
_comment_load di funzione ($cid) {
  db_fetch_object di ritorno (db_query (“PRESCELTO * DA {osservazioni} DOVE cid = %d„, $cid));
}

/**
 * Ottenere il conteggio di commento per un nodo.
 *
 * @param $nid
 * L'identificazione di nodo
 * @return
 * Il conteggio di commento.
 */
comment_num_all di funzione ($nid) {
  $cache statico;

  se (! isset ($cache [$nid])) {
    $cache [$nid] = db_result (db_query (“comment_count PRESCELTO DA {node_comment_statistics} DOVE nid = %d„, $nid));
  }
  $cache di ritorno [$nid];
}

/**
 * Ottenere il conteggio di risposte per un commento.
 *
 * @param $pid
 * L'identificazione di commento
 * @return
 * Il conteggio di risposte.
 */
comment_num_replies di funzione ($pid) {
  $cache statico;

  se (! isset ($cache [$pid])) {
    $cache [$pid] = db_result (db_query (“CONTEGGIO PRESCELTO (cid) DA {osservazioni} DOVE pid = %d E condizione = %d„, $pid, COMMENT_PUBLISHED));
  }

  $cache di ritorno [$pid];
}

/**
 * Ottenere il numero di nuove osservazioni per l'utente corrente ed il nodo specificato.
 *
 * @param $nid
 * nodo-identificazione per contare le osservazioni per
 * @param $timestamp
 * tempo di contare da (difetti a periodo di ultimo accesso di utente
 * al nodo)
 */
comment_num_new di funzione ($nid, $timestamp = 0) {
  $user globale;

  se ($user->uid) {
    // richiama il timestamp a cui l'utente corrente ha osservato l'ultima volta
    // ha specificato il nodo.
    se (! $timestamp) {
      $timestamp = node_last_viewed ($nid);
    }
    $timestamp = ($timestamp > NODE_NEW_LIMIT? $timestamp: NODE_NEW_LIMIT);

    Uso di // il timestamp richiamare il numero di nuove osservazioni.
    $result = db_result (db_query (“il CONTEGGIO PRESCELTO (c.cid) {nodo} da n INTERNA UNISCE {osservazioni} la c SU n.nid = c.nid DOVE n.nid = %d E timestamp > %d E c.status = %d„, $nid, $timestamp, COMMENT_PUBLISHED));

    $result di ritorno;
  }
  altrimenti {
    ritorno 0;
  }

}

/**
 * Convalidare i dati di commento.
 *
 * @param $edit
 * Un containig associativo di allineamento i dati di commento.
 * @return
 * Il $edit originale.
 */
comment_validate di funzione ($edit) {
  $user globale;

  // invoca altri alimentatori di convalida
  comment_invoke_comment ($edit, “convalidano ");

  se (isset ($edit [“data„])) {
    // a partire dal PHP 5.1.0, strtotime restituisce FALSO su guasto anziché -1.
    se (strtotime ($edit [“data„]) <= 0) {
      form_set_error (“data„, t (“dovete specificare un date.") valido);
    }
  }
  se (isset ($edit [“autore„]) &&!  {
    form_set_error (“autore„, t (“dovete specificare un author.") valido);
  }

  Validità del controllo di // del nome, della posta e del homepage (se dato)
  se (! $user->uid || isset ($edit [“is_anonymous„])) {
    $node = node_load ($edit [“nid„]);
    se (variable_get (“comment_anonymous_„. $NODE->TYPE, COMMENT_ANONYMOUS_MAYNOT_CONTACT) > COMMENT_ANONYMOUS_MAYNOT_CONTACT) {
      se ($edit [“nome„]) {
        $taken = db_result (db_query (“SELEZIONARE IL CONTEGGIO (uid) A PARTIRE {utenti} DOVE PIÙ BASSO (nome) = “%s„„, $edit [“nome„]));

        se ($taken! = 0) {
          form_set_error (“nome„, t (“il nome che avete usato appartiene ad un user.") registrato);
        }

      }
      altrimenti se (variable_get (“comment_anonymous_„. $NODE->TYPE, == COMMENT_ANONYMOUS_MUST_CONTACT DI COMMENT_ANONYMOUS_MAYNOT_CONTACT)) {
        form_set_error (“nome„, t (“dovete lasciare il vostro name."));
      }

      se ($edit [“posta„]) {
        se (! valid_email_address ($edit [“posta„])) {
          form_set_error (“posta„, t (“il email address che avete specificato è invalid."));
        }
      }
      altrimenti se (variable_get (“comment_anonymous_„. $NODE->TYPE, == COMMENT_ANONYMOUS_MUST_CONTACT DI COMMENT_ANONYMOUS_MAYNOT_CONTACT)) {
        form_set_error (“posta„, t (“dovete lasciare un email address ."));
      }

      se ($edit [“homepage„]) {
        se (! valid_url ($edit [“homepage„], ALLINEANO)) {
          form_set_error (“homepage„, t (“Il URL del vostro homepage è non valido. Ricordar che deve essere completamente - qualificato, cioè del  della forma http://example.com/directory ."));
        }
      }
    }
  }

  restituire $edit;
}

/**
 * Generare aggiungere dato che, la forma di commento di base ad un nodo o ad un'esposizione ad una pagina separata.
 *
 * @param $title
 * Usato.
 * forme del @ingroup
 * comment_form_validate di @see ()
 * comment_form_submit di @see ()
 */
comment_form di funzione (&$form_state, $edit, $title = POSIZIONE DI SEGNALE MINIMO) {
  $user globale;

  $op = isset ($_POST [“op„])? $_POST [“op„]: '';
  $node = node_load ($edit [“nid„]);

  se (! variable_get del && di $user->uid (“comment_anonymous_„. $node->type, COMMENT_ANONYMOUS_MAYNOT_CONTACT)! = COMMENT_ANONYMOUS_MAYNOT_CONTACT) {
    drupal_add_js (drupal_get_path (“modulo„, “commento "). “/comment.js ");
  }
  allineamento di $edit += (della posta “di nome => '', “homepage„ => “'' '',„„ del =>);
  se ($user->uid) {
    se (! ($edit [“cid„]) user_access vuoti del && (“amministrare le osservazioni ")) {
      se (! svuotare ($edit [“autore„])) {
        $author = $edit [“autore„];
      }
      elseif (! svuotare ($edit [“nome„])) {
        $author = $edit [“nome„];
      }
      altrimenti {
        $author = $edit [“registered_name„];
      }

      se (! svuotare ($edit [“condizione„])) {
        $status = $edit [“condizione„];
      }
      altrimenti {
        $status = 0;
      }

      se (! svuotare ($edit [“data„])) {
        $date = $edit [“data„];
      }
      altrimenti {
        $date = format_date ($edit [“timestamp„], “abitudine„, “Y-m-d H: i O ");
      }

      $form [“admin„] = allineamento (
        => “fieldset„ “del #type„,
        “#title„ => t (“gestione "),
        => “#collapsible„ ALLINEARE,
        => “#collapsed„ ALLINEARE,
        => -2 “del #weight„,
      );

      se ($edit [“registered_name„]! = '') {
        // il commento è da un utente registrato
        $form [“admin„] [“autore„] = allineamento (
          => “textfield„ “del #type„,
          “#title„ => t (“creato vicino "),
          “#size„ il => 30,
          => 60 “del #maxlength„,
          => “utente/autocomplete„ “del #autocomplete_path„,
          => $author “del #default_value„,
          => -1 “del #weight„,
        );
      }
      altrimenti {
        // il commento è da un utente anonimo
        $form [“is_anonymous„] = allineamento (
          => “valore„ “del #type„,
          => “del #value„ ALLINEARE,
        );
        $form [“admin„] [“nome„] = allineamento (
          => “textfield„ “del #type„,
          “#title„ => t (“creato vicino "),
          “#size„ il => 30,
          => 60 “del #maxlength„,
          => $author “del #default_value„,
          => -1 “del #weight„,
        );
        $form [“admin„] [“posta„] = allineamento (
          => “textfield„ “del #type„,
          “#title„ => t (“email "),
          => 64 “del #maxlength„,
          “#size„ il => 30,
          => $edit [“posta„ “del #default_value„],
          “#description„ => t (“il contenuto di questo campo è mantenuto riservato e non sarà indicato publicly."),
        );

        $form [“admin„] [“homepage„] = allineamento (
          => “textfield„ “del #type„,
          “#title„ => t (“homepage "),
          => 255 “del #maxlength„,
          “#size„ il => 30,
          => $edit [“homepage„ “del #default_value„],
        );
      }

      

      

    }
    altrimenti {
      $form [=> t (“il vostro nome ") “del #title„„ del => ““del #type “di _author„] = allineamento (articolo„, tema del => “del #value„ (“username„, $user)
      );
      $form [“autore„] = allineamento (del #value„ del => “del #type => $user->name “,„„ “di valore);
    }
  }
  altrimenti se (variable_get (“comment_anonymous_„. $NODE->TYPE, == COMMENT_ANONYMOUS_MAY_CONTACT DI COMMENT_ANONYMOUS_MAYNOT_CONTACT)) {
    $form [il => la t (“il vostro nome ") “del #title„„ del => ““del #type “di nome„] = allineamento (il textfield„, => 60 “del #maxlength„, “#size„ il => 30, => $edit [“nome„ “del #default_value„]? $edit [“nome„]: variable_get (“anonimo„, t (“anonimo "))
    );

    $form [“posta„] = allineamento (il textfield„„ del => “del #type “, “#title„ il => la t (“email "), “#maxlength„ il => 64, “#size„ il => 30, “#default_value„ il => $edit [“posta„], “#description„ il => t (“il contenuto di questo campo è mantenuto riservato e non sarà indicato publicly.")
    );

    $form [“del #title„„ del => ““del #type “del homepage„] = allineamento (il textfield„, => 255 “del #maxlength„, “#size„ del => 30, “del #default_value„ il => $edit il => la t (“homepage ") [“homepage„]);
  }
  altrimenti se (variable_get (“comment_anonymous_„. $NODE->TYPE, == COMMENT_ANONYMOUS_MUST_CONTACT DI COMMENT_ANONYMOUS_MAYNOT_CONTACT)) {
    $form [il => la t (“il vostro nome ") “del #title„„ del => ““del #type “di nome„] = allineamento (il textfield„, => 60 “del #maxlength„, “#size„ il => 30, => $edit [“nome„ “del #default_value„]? $edit [“nome„]: variable_get (“anonimo„, t (“anonimo ")), => “#required„ ALLINEARE);

    $form [“posta„] = allineamento (il textfield„„ del => “del #type “, “#title„ il => la t (“email "), “#maxlength„ il => 64, “#size„ il => 30, “#default_value„ il => $edit [“posta„], “#description„ il => t (“il contenuto di questo campo è mantenuto riservato e non sarà indicato publicly."), => “#required„ ALLINEARE);

    $form [“del #title„„ del => ““del #type “del homepage„] = allineamento (il textfield„, => 255 “del #maxlength„, “#size„ del => 30, “del #default_value„ il => $edit il => la t (“homepage ") [“homepage„]);
  }

  se (variable_get (“comment_subject_field_„. $node->type, 1) == 1) {
    $form [=> t (“soggetto ") “del #title„„ del => ““del #type “dell'oggetto„] = allineamento (textfield„, => 64 “del #maxlength„, => “del #default_value„! svuotare ($edit [“oggetto„])? $edit [“oggetto„]: '');
  }

  se (! vuoto ($edit [“commento„])) {
    $default = $edit [“commento„];
  }
  altrimenti {
    $default = '';
  }

  $form [“comment_filter„] [“commento„] = allineamento (
    => “textarea„ “del #type„,
    “#title„ => t (“commento "),
    => 15 “dei #rows„,
    => $default “del #default_value„,
    => “#required„ ALLINEARE,
  );
  se (! isset ($edit [“disposizione„])) {
    $edit [“disposizione„] = FILTER_FORMAT_DEFAULT;
  }
  $form [“comment_filter„] [“disposizione„] = filter_form ($edit [“disposizione„]);

  $form [“cid„] = allineamento (=> “del #value„„ del => ““del #type valore„! svuotare ($edit [“cid„])? $edit [“cid„]: POSIZIONE DI SEGNALE MINIMO);
  $form [“pid„] = allineamento (=> “del #value„„ del => ““del #type valore„! svuotare ($edit [“pid„])? $edit [“pid„]: POSIZIONE DI SEGNALE MINIMO);
  
  $form [“uid„] = allineamento (=> “del #value„„ del => ““del #type valore„! svuotare ($edit [“uid„])? $edit [“uid„]: POSIZIONE DI SEGNALE MINIMO);

  Esposizione di // soltanto salvo il tasto se la previsione è facoltativa o se siamo nel modo di previsione.
  // mostriamo il tasto di risparmio nel modo di previsione anche se ci sono errori della forma in modo che
  gli elementi facoltativi della forma di // (per esempio, captcha) possono essere aggiornati nel modo di previsione.
  se (! && di form_get_errors () ((variable_get (“comment_preview_„. $NODE->TYPE, == COMMENT_PREVIEW_OPTIONAL DI COMMENT_PREVIEW_REQUIRED)) || (== t (“previsione ") di $op) || (== t di $op (“salvo ")))) {
    $form [“presentare„] = allineamento (del => t (“salvo "), “del #weight„ “del #value„„ del => ““del #type presentare„, il => 19);
  }

  $form [del => t (“previsione "), “del #weight„ “del #value„„ del => ““del #type “di previsione„] = allineamento (tasto„, => 20);
  $form [“#token„] = “commento„. $edit [“nid„]. (isset ($edit [“pid„])? $edit [“pid„]: '');

  se (== t (“previsione ") di $op) {
    $form [“#after_build„] = allineamento (“comment_form_add_preview ");
  }

  se (svuotare ($edit [“cid„]) && vuoto ($edit [“pid„])) {
    $form [“#action„] = URL (“commento/risposta„. $edit [“nid„]);
  }

  $form di ritorno;
}

/**
 * Tema la scatola della forma di commento.
 *
 * @param $edit
 * La struttura della forma.
 * @param $title
 * Il titolo della forma.
 */
comment_form_box di funzione ($edit, $title = POSIZIONE DI SEGNALE MINIMO) {
  tema di ritorno (“scatola„, $title, drupal_get_form (“comment_form„, $edit, $title));
}

/**
 * Formare il costruttore; Generare e convalidare una forma di previsione di commento.
 *
 * forme del @ingroup
 */
comment_form_add_preview di funzione ($form, &$form_state) {
  $user globale;
  $edit = $form_state [“valori„];
  drupal_set_title (t (“commento di previsione "));

  $output = '';
  $node = node_load ($edit [“nid„]);

  // invoca la convalida completa per la forma, per proteggere dal luogo trasversale
  falsi di richiesta di // (CSRF) e valori arbitrari della regolazione per i campi come
  // la disposizione dell'input. Vedere in anteprima il commento soltanto quando la convalida della forma non fa
  // ha fissato tutti gli errori.
  drupal_validate_form ($form [“form_id„] [“#value„], $form, $form_state);
  se (! form_get_errors ()) {
    _comment_form_submit ($edit);
    $comment = (oggetto) $edit;

    Attaccatura di // le informazioni di tempo e dell'utente.
    se (! svuotare ($edit [“autore„])) {
      ;
    }
    elseif (&& di $user->uid! isset ($edit [“is_anonymous„])) {
      $account = $user;
    }
    se (! svuotare ($account)) {
      $comment->uid = $account->uid;
      $comment->name = check_plain ($account->name);
    }
    elseif (svuotare ($comment->name)) {
      $comment->name = variable_get (“anonimo„, t (“anonimo "));
    }
    $comment->timestamp =! svuotare ($edit [“timestamp„])? $edit [“timestamp„]: tempo ();
    $output. = tema (“comment_view„, $comment, $node);
  }
  $form [“comment_preview„] = allineamento (
    => $output “del #value„,
    => -100 “del #weight„,
    previsione " del class= del 
 ““del #prefix >„,
    => “
„ “del #suffix„,
  );

  $output = '';

  se ($edit [“pid„]) {
    $comment = db_fetch_object (db_query (“c.* PRESCELTI, u.uid, u.name COME registered_name, u.signature, u.picture, u.data {osservazioni} dalla c INTERNA UNISCONO {utenti} la u SU c.uid = u.uid DOVE c.cid = %d E c.status = %d„, $edit [“pid„], COMMENT_PUBLISHED));
    $comment = drupal_unpack ($comment);
    $comment->name = $comment->uid? $comment->registered_name: $comment->name;
    $output. = tema (“comment_view„, $comment, $node);
  }
  altrimenti {
    $suffix = svuotano ($form [“#suffix„])? '': $form [“#suffix„];
    $form [“#suffix„] = $suffix. node_view ($node);
    $edit [“pid„] = 0;
  }

  $form [“comment_preview_below„] = allineamento (=> 100 del => $output, “del #weight„ “del #value„);

  $form di ritorno;
}

/**
 * Convalidare le presentazioni della forma di commento.
 */
comment_form_validate di funzione ($form, &$form_state) {
  $user globale;
  se (=== 0 di $user->uid) {
    foreach (allineamento (“nome„, “homepage„, “posta ") come $field) {
      // ha regolato il biscotto per i 365 giorni.
      se (isset ($form_state [“valori„] [$field])) {
        setcookie (“comment_info_„. $field, $form_state [“valori„] [$field], tempo () + 31536000, “/");
      }
    }
  }
  comment_validate ($form_state [“valori„]);
}

/**
 * Preparare un commento per la presentazione.
 *
 * @param $comment_values
 * Un allineamento associativo che contiene i dati di commento.
 */
_comment_form_submit di funzione (&$comment_values) {
  allineamento di $comment_values += (“oggetto„ => '');
  se (! isset ($comment_values [“data„])) {
    $comment_values [“data„] = “ora„;
  }
  $comment_values [“timestamp„] = strtotime ($comment_values [“data„]);
  se (isset ($comment_values [“autore„])) {
    ;
    $comment_values [“uid„] = $account->uid;
    $comment_values [“nome„] = $comment_values [“autore„];
  }
  // convalida l'oggetto del commento. Se non specificato, estratto
  // uno dal corpo del commento.
  se (disposizione ($comment_values [“oggetto„]) == '') {
    // il corpo può essere in tutta la disposizione, così noi:
    Filtro da // 1) esso nel HTML
    Striscia di // 2) fuori tutte le modifiche del HTML
    Entità del convertito di // 3) di nuovo al plain-text.
    Nota di //: la disposizione è controllata da check_markup ().
    $comment_values [“oggetto„] = disposizione (truncate_utf8 (decode_entities (strip_tags (check_markup ($comment_values [“commento„], $comment_values [“disposizione„]))), 29, ALLINEANO));
    I casi del bordo di // dove il corpo di commento è popolato soltanto dalle modifiche del HTML 
    // richiede un oggetto di difetto.
    se (== di $comment_values [“oggetto„] '') {
      $comment_values [“oggetto„] = t (“(nessun oggetto) ");
    }
  }
}

/**
 * Presentazioni trattate della forma di commento; preparare il commento, immagazzinarlo e prefiggere un obiettivo di nuovo indirizzo.
 */
comment_form_submit di funzione ($form, &$form_state) {
  _comment_form_submit ($form_state [“valori„]);
  se ($cid = comment_save ($form_state [“valori„])) {
    $node = node_load ($form_state [“valori„] [“nid„]);
    $page = comment_new_page_count ($node->comment_count, 1, $node);
    $form_state [“riorientare„] = allineamento (“nodo„. $node->nid, $page, “comment-$cid„);
    ritorno;
  }
}

/**
 * Tema un singolo blocchetto di commento.
 *
 * @param $comment
 * L'oggetto di commento.
 * @param $node
 * Il nodo di commento.
 * @param $links
 * Un allineamento associativo che contiene i collegamenti di controllo.
 * @param $visible
 * Interruttori fra vista piegata/spiegata.
 * @ingroup themeable
 */
theme_comment_view di funzione ($comment, $node, $links = l'allineamento (), $visible = ALLINEANO) {
  statico $first_new = ALLINEANO;

  $output = '';
  $comment->new = node_mark ($comment->nid, $comment->timestamp);
  se (&& $comment->new di $first_new! = MARK_READ) {
    // assegna l'ancoraggio soltanto per il primo nuovo commento. Ciò evita il duplicato
    attributi di identificazione di // ad una pagina.
    $first_new = FALSO;
    $output. = “id= di  \ n„;
  }

  $output. = “id= di cid \ “> \ n„;

  L'interruttore di // al piegato a/ha spiegato la vista del commento
  se ($visible) {
    $comment->comment = check_markup ($comment->comment, $comment->format, FALSI);

    Gancio di commento api di //
    comment_invoke_comment ($comment, “vista ");

    $output. = tema (“commento„, $comment, $node, $links);
  }
  altrimenti {
    $output. = tema (“comment_folded„, $comment);
  }

  $output di ritorno;
}


/**
 * Sviluppare una forma di controllo di commento.
 *
 * @param $mode
 * Modo di esposizione di commento.
 * @param $order
 * Modo di ordine di commento.
 * @param $comments_per_page
 * Commenta per pagina.
 * forme del @ingroup
 */
comment_controls di funzione ($mode = COMMENT_MODE_THREADED_EXPANDED, $order = COMMENT_ORDER_NEWEST_FIRST, $comments_per_page = 50) {
  $form [“modo„] = allineamento („ il => ““del #type seleziona„,
    => $mode “del #default_value„,
    _comment_get_modes del => “di #options„ (),
    => 1 “del #weight„,
  );
  $form [“ordine„] = allineamento (
    „ il => ““del #type seleziona„,
    => $order “del #default_value„,
    _comment_get_orders del => “di #options„ (),
    => 2 “del #weight„,
  );
  foreach (_comment_per_page () come $i) {
    $options [$i] = t (“! osservazioni per pagina„, allineamento (“! „ un => $i));
  }
  $form [“comments_per_page„] = allineamento („ il => ““del #type seleziona„,
    => $comments_per_page “del #default_value„,
    => $options “di #options„,
    => 3 “del #weight„,
  );

  $form [“presentare„] = allineamento („ il => ““del #type presenta„,
    “#value„ => t (“salvo le regolazioni "),
    => 20 “del #weight„,
  );

  $form di ritorno;
}

/**
 * Cassetta di controllo di commento di tema dove l'utente può cambiare il modo di esposizione di difetto e visualizzare l'ordine delle osservazioni.
 *
 * @param $form
 * La struttura della forma.
 * @ingroup themeable
 */
theme_comment_controls di funzione ($form) {
  $output = “class= del 
„;
  $output. = drupal_render ($form);
  $output. = “
„;
  $output. = “descrizione " del class= del 
„. t (“selezionare il vostro senso preferred visualizzare le osservazioni e scattarsi “salvo le regolazioni„ per attivare il vostro changes."). “
„;
  tema di ritorno (“scatola„, t (“opzioni di osservazione di commento "), $output);
}

/**
 * Presentazioni trattate della forma dei comment_controls.
 */
comment_controls_submit di funzione ($form, &$form_state) {
  $user globale;

  $mode = $form_state [“valori„] [“modo„];
  $order = $form_state [“valori„] [“ordine„];
  $comments_per_page = $form_state [“valori„] [“comments_per_page„];

  se ($user->uid) {
    $account = user_save ($user, allineamento (=> $mode “di modo„, => $comments_per_page del => $order, “di comments_per_page„ “di specie„));
    // termina se un errore si presentasse durante il user_save ().
    se (! $account) {
      drupal_set_message (t (“utente di risparmio di errore account."), “errore ");
      ritorno;
    }
    $user = $account;
  }
  altrimenti {
    $_SESSION [“comment_mode„] = $mode;
    $_SESSION [“comment_sort„] = $order;
    $_SESSION [“comment_comments_per_page„] = $comments_per_page;
  }
}

/**
 * Variabili trattate per comment.tpl.php.
 *
 * @see comment.tpl.php
 * theme_comment di @see ()
 */
template_preprocess_comment di funzione (&$variables) {
  $comment = $variables [“commento„];
  $node = $variables [“nodo„];
  $variables [“autore„] = tema (“username„, $comment);
  $variables [“soddisfare„] = $comment->comment;
  $variables [“data„] = format_date ($comment->timestamp);
  $variables [“collegamenti„] = isset ($variables [“collegamenti„])? tema (“collegamenti„, $variables [“collegamenti„]): '';
  $variables [“nuovo„] = $comment->new? t (“nuovo "): '';
  $variables [“immagine„] = theme_get_setting (“toggle_comment_user_picture ")? tema (“user_picture„, $comment): '';
  $variables [“firma„] = $comment->signature;
  $variables [“presentato„] = tema (“comment_submitted„, $comment);
  $variables [“titolo„] = l ($comment->subject, $_GET [“q„], allineamento (=> “comment-$comment->cid„ “del frammento„));
  $variables [“template_files„] [] = “commento„. $node->type;
  // ha fissato la condizione ad una rappresentazione di stringa del comment->status.
  se (isset ($comment->preview)) {
    $variables [“condizione„] = “commentare-vedono in anteprima„;
  }
  altrimenti {
    $variables [“condizione„] = (== COMMENT_NOT_PUBLISHED di $comment->status)? “commentare-non pubblicato„: “commentare-pubblicato„;
  }
}

/**
 * Variabili trattate per comment-folded.tpl.php.
 *
 * @see comment-folded.tpl.php
 * il @see theme_comment_folded ()
 */
la funzione template_preprocess_comment_folded (&$variables) {
  $comment = $variables [“commento„];
  $variables [“autore„] = tema (“username„, $comment);
  $variables [“data„] = format_date ($comment->timestamp);
  $variables [“nuovo„] = $comment->new? t (“nuovo "): '';
  $variables [“titolo„] = l ($comment->subject, comment_node_url (). “/„. $comment->cid, allineamento (=> “comment-$comment->cid„ “del frammento„));
}

/**
 * Vista crollata piana di commento di tema.
 *
 * @param $comment
 * Il commento da essere di tema.
 * @param $node
 * Il nodo di commento.
 * @ingroup themeable
 */
la funzione theme_comment_flat_collapsed ($comment, $node) {
  tema di ritorno (“comment_view„, $comment, $node, '', 0);
}

/**
 * Vista ampliata piana di commento di tema.
 *
 * @param $comment
 * Il commento da essere di tema.
 * @param $node
 * Il nodo di commento.
 * @ingroup themeable
 */
la funzione theme_comment_flat_expanded ($comment, $node) {
  tema di ritorno (“comment_view„, $comment, $node, module_invoke_all (“collegamento„, “commento„, $comment, 0));
}

/**
 * Il filetto di commento di tema è sprofondato vista.
 *
 * @param $comment
 * Il commento da essere di tema.
 * @param $node
 * Il nodo di commento.
 * @ingroup themeable
 */
la funzione theme_comment_thread_collapsed ($comment, $node) {
  tema di ritorno (“comment_view„, $comment, $node, '', 0);
}

/**
 * Vista ampliata filetto di commento di tema.
 *
 * @param $comment
 * Il commento da essere di tema.
 * @param $node
 * Il nodo di commento.
 * @ingroup themeable
 */
la funzione theme_comment_thread_expanded ($comment, $node) {
  tema di ritorno (“comment_view„, $comment, $node, module_invoke_all (“collegamento„, “commento„, $comment, 0));
}

/**
 * Tema “non potete inviare un avviso di osservazioni„.
 *
 * @param $node
 * Il nodo di commento.
 * @ingroup themeable
 */
la funzione theme_comment_post_forbidden ($node) {
  $user globale;
  $authenticated_post_comments statico;
  
  se (! $user->uid) {
    se (! isset ($authenticated_post_comments)) {
      // abbiamo prodotto soltanto tutto il collegamento se siamo sicuri, quel utenti otteniamo il permesso
      // per inviare le osservazioni entrando. Inoltre localmente nascondiamo questi informazioni.
      $authenticated_post_comments = array_key_exists (DRUPAL_AUTHENTICATED_RID, user_roles (ALLINEARE, “osservazioni dell'alberino ") + user_roles (ALLINEARE, “l'alberino commenta senza approvazione "));
    }
    
    se ($authenticated_post_comments) {
      // non possiamo usare il drupal_get_destination () perché questi collegamenti
      // a volte compare a /node ed alle pagine dell'elenco di tassonomia.
      se (variable_get (“comment_form_location_„. $NODE->TYPE, == COMMENT_FORM_SEPARATE_PAGE DI COMMENT_FORM_SEPARATE_PAGE)) {
        $destination = “destination=„. drupal_urlencode (“commento/reply/$node->nid#comment-form„);
      }
      altrimenti {
        $destination = “destination=„. drupal_urlencode (“node/$node->nid#comment-form„);
      }

      se (variable_get (“user_register„, 1)) {
        Gli utenti di // possono registrarsi.
        t di ritorno (“URL del => “del @login„ " del @register " del href= di Login o >register all'alberino commenta„, allineamento ((“utente/inizio attività„, allineamento (=> $destination “di domanda„));
      }
      altrimenti {
        I admins di // soltanto possono aggiungere i nuovi utenti, nessun registro pubblico.
        t di ritorno (“URL del => “del @login„ " del @login " del href= di Login all'alberino commenta„, allineamento ((“utente/inizio attività„, allineamento (=> $destination “di domanda„))));
      }
    }
  }
}

/**
 * Variabili trattate per comment-wrapper.tpl.php.
 *
 * @see comment-wrapper.tpl.php
 * theme_comment_wrapper di @see ()
 */
template_preprocess_comment_wrapper di funzione (&$variables) {
  // fornisce informazioni contestuali.
  $variables [“display_mode„] = _comment_get_display_setting (“modo„, $variables [“nodo„]);
  $variables [“display_order„] = _comment_get_display_setting (“specie„, $variables [“nodo„]);
  $variables [“comment_controls_state„] = variable_get (“comment_controls_„. >type di $variables [“nodo„] -, COMMENT_CONTROLS_HIDDEN);
  $variables [“template_files„] [] = “commentare-involucro„. >type di $variables [“nodo„] -;
}

/**
 * Di tema “presentato da…„ avviso.
 *
 * @param $comment
 * Il commento.
 * @ingroup themeable
 */
la funzione theme_comment_submitted ($comment) {
  t di ritorno (“presentato vicino! username su @datetime. „,
    allineamento (
      “! tema del => del username„ (“username„, $comment),
      format_date del => “del @datetime„ ($comment->timestamp)
    ));
}

/**
 * Restituire un allineamento dei modi di osservazione per gli elenchi di commento.
 *
 * Non possiamo usare un allineamento di variabile globale perché il sistema della scena
 * non è inizializzato ancora quando il modulo di commento è caricato.
 */
_comment_get_modes di funzione () {
  allineamento di ritorno (
    => t (“lista piana di COMMENT_MODE_FLAT_COLLAPSED - crollata "),
    => t (“lista piana di COMMENT_MODE_FLAT_EXPANDED - ampliata "),
    => t (“lista filettata di COMMENT_MODE_THREADED_COLLAPSED - crollata "),
    => t (“lista filettata di COMMENT_MODE_THREADED_EXPANDED - ampliata ")
  );
}

/**
 * Restituire un allineamento degli ordini di osservazione per gli elenchi di commento.
 *
 * Non possiamo usare un allineamento di variabile globale perché il sistema della scena
 * non è inizializzato ancora quando il modulo di commento è caricato.
 */
_comment_get_orders di funzione () {
  allineamento di ritorno (
    => t (“data - i più nuovi prima ") di COMMENT_ORDER_NEWEST_FIRST,
    => t (“data - il più vecchio prima ") di COMMENT_ORDER_OLDEST_FIRST
  );
}

/**
 * Restituire un allineamento “osservazioni per delle regolazioni di pagina„ da cui l'utente
 * può scegliere.
 */
_comment_per_page di funzione () {
  drupal_map_assoc di ritorno (allineamento (10, 30, 50, 70, 90, 150, 200, 250, 300));
}

/**
 * Restituire una regolazione corrente dell'esposizione di commento
 *
 * @param $setting
 * può essere uno di questi: “modo„, “specie„, “comments_per_page„
 * @param $node
 * Il nodo di commento in questione.
 */
funzione che _comment_get_display_setting ($setting, $node) {
  $user globale;

  se (isset ($_GET [$setting])) {
    $value = $_GET [$setting];
  }
  altrimenti {
    // ottiene il difetto del luogo della regolazione
    commutare ($setting) {
      mettere “il modo„:
        $default = variable_get (“comment_default_mode_„. $node->type, COMMENT_MODE_THREADED_EXPANDED);
        rottura;
      caso “specie„:
        $default = variable_get (“comment_default_order_„. $node->type, COMMENT_ORDER_NEWEST_FIRST);
        rottura;
      caso “comments_per_page„:
        $default = variable_get (“comment_default_per_page_„. $node->type, 50);
    }
    se (variable_get (“comment_controls_„. $NODE->TYPE, == COMMENT_CONTROLS_HIDDEN DI COMMENT_CONTROLS_HIDDEN)) {
      // se i comandi di commento sono difetto disabile del luogo di uso
      $value = $default;
    }
    altrimenti {
      // al contrario uso regolazione dell'utente se insieme
      se (&& $user->$setting del isset ($user->$setting)) {
        $value = $user->$setting;
      }
      altrimenti se (isset ($_SESSION [“comment_„. && $_SESSION [“comment_„ di $setting]). $setting]) {
        $value = $_SESSION [“comment_„. $setting];
      }
      altrimenti {
        $value = $default;
      }
    }
  }
  $value di ritorno;
}

/**
 * Aggiorna le statistiche di commento per un nodo dato. Ciò dovrebbe essere denominata c'è ne
 * cronometrare un commento si aggiunge, cancellato, o è aggiornato.
 *
 * I seguenti campi sono contenuti nella tabella di node_comment_statistics.
 * - last_comment_timestamp: il timestamp di ultimo commento per questo nodo o il nodo genera il bollo se nessun'osservazione esiste per il nodo.
 * - last_comment_name: il nome del manifesto anonimo per l'ultimo commento
 * - last_comment_uid: il uid del manifesto per l'ultimo commento per questo nodo o il uid degli autori di nodo se nessun'osservazione esiste per il nodo.
 * - comment_count: il numero totale di approvato/ha pubblicato le osservazioni su questo nodo.
 */
_comment_update_node_statistics di funzione ($nid) {
  $count = db_result (db_query (“CONTEGGIO PRESCELTO (cid) DA {osservazioni} DOVE nid = %d E condizione = %d„, $nid, COMMENT_PUBLISHED));

  le osservazioni di // esistono
  se ($count > 0) {
    $last_reply = db_fetch_object (db_query_range (“cid PRESCELTO, nome, timestamp, uid DA {osservazioni} DOVE nid = %d E condizione = ORDINE di %d da cid DESC„, $nid, COMMENT_PUBLISHED, 0, 1));
    db_query (“l'AGGIORNAMENTO {node_comment_statistics} HA REGOLATO il comment_count = %d, last_comment_timestamp = %d, last_comment_name = “%s„, last_comment_uid = %d DOVE nid = %d„, $count, $last_reply->timestamp, $last_reply->uid? '': $last_reply->name, $last_reply->uid, $nid);
  }

  // nessun osservazioni
  altrimenti {
    $node = db_fetch_object (db_query (“uid PRESCELTO, generato DA {nodo} DOVE nid = %d„, $nid));
    db_query (“l'AGGIORNAMENTO {node_comment_statistics} HA REGOLATO il comment_count = 0, last_comment_timestamp = %d, last_comment_name = '', last_comment_uid = %d DOVE nid = %d„, $node->created, $node->uid, $nid);
  }
}

/**
 * Invocare un funzionamento di hook_comment () in tutti i moduli.
 *
 * @param &$comment
 * Un oggetto di commento.
 * @param $op
 * Una stringa che contiene il nome del funzionamento di commento.
 * @return
 * Valore restituito dei ganci invocati.
 */
comment_invoke_comment di funzione (&$comment, $op) {
  $return = allineamento ();
  foreach (module_implements (“commento ") come $name) {
    $function = $name. “_comment„;
    $result = $function ($comment, $op);
    se (&& del isset ($result) is_array ($result)) {
      $return = array_merge ($return, $result);
    }
    altrimenti se (isset ($result)) {
      $return [] = $result;
    }
  }
  $return di ritorno;
}

/**
 * Generare il vancode.
 *
 * Consiste di un carattere principale che indica la lunghezza, seguita dalle cifre di N
 * con un valore numerico nella base 36. Vancodes può essere fascicolato come stringhe
 * senza scompigliare in su ordine numerico.
 *
 * Va:
 * 00, 01, 02,…, 0y, 0z,
 * 110, 111,…, 1zy, 1zz,
 * 2100, 2101,…, 2zzy, 2zzz,
 * 31000, 31001,…
 */
funzione int2vancode ($i = 0) {
  $num = base_convert ((int) $i, 10, 36);
  $length = strlen ($num);
  chr di ritorno ($length + ord (“0„) - 1). $num;
}

/**
 * Decodificare il vancode di nuovo ad un numero intero.
 */
funzione vancode2int ($c = “00„) {
  base_convert di ritorno (substr ($c, 1), 36, 10);
}

/**
 * Esecuzione del hook_hook_info ().
 */
comment_hook_info di funzione () {
  allineamento di ritorno (
    allineamento del => “di commento„ (
      allineamento del => “di commento„ (
        “inserire„ l'allineamento del => (
          “funzionamenti quando„ => t (“dopo il salvataggio del commento nuovo "),
        ),
        allineamento del => “dell'aggiornamento„ (
          “funzionamenti quando„ => t (“dopo il salvataggio del commento aggiornato "),
        ),
        allineamento del => “di cancellazione„ (
          “funzionamenti quando„ => t (“dopo la cancellazione del commento ")
        ),
        allineamento del => “di vista„ (
          “funzionamenti quando„ => t (“quando un commento sta osservando da un utente autenticato ")
        ),
      ),
    ),
  );
}

/**
 * Esecuzione del hook_action_info ().
 */
comment_action_info di funzione () {
  allineamento di ritorno (
    allineamento del => “di comment_unpublish_action„ (
      “descrizione„ => t (“commento di Unpublish "),
      “scriv„ il => a macchina “commento„,
      => “configurabile„ FALSO,
      “aggancia„ l'allineamento del => (
        “commento„ allineamento del => (“inserto„, “aggiornamento "),
      )
    ),
    allineamento del => “di comment_unpublish_by_keyword_action„ (
      “descrizione„ => t (“commento di Unpublish che contiene le parole chiavi "),
      “scriv„ il => a macchina “commento„,
      => “configurabile„ ALLINEARE,
      “aggancia„ l'allineamento del => (
        “commento„ allineamento del => (“inserto„, “aggiornamento "),
      )
    )
  );
}

/**
 * Azione di Drupal a unpublish un commento.
 *
 * @param $context
 * Allineamento chiud a chiave. Deve contenere l'identificazione del commento se $comment non è passato.
 * @param $comment
 * Un oggetto facoltativo di commento.
 */
comment_unpublish_action di funzione ($comment, $context = allineamento ()) {
  se (isset ($comment->cid)) {
    $cid = $comment->cid;
    $subject = $comment->subject;
  }
  altrimenti {
    $cid = $context [“cid„];
    $subject = db_result (db_query (“oggetto PRESCELTO DA {osservazioni} DOVE cid = %d„, $cid));
  }
  db_query (“l'AGGIORNAMENTO {osservazioni} HA REGOLATO la condizione = %d DOVE cid = %d„, COMMENT_NOT_PUBLISHED, $cid);
  cane da guardia (“azione„, “commento non pubblicato %subject. „, allineamento (=> $subject “di %subject„));
}

/**
 * Formare il costruttore; Preparare una forma per le parole chiavi messe in.
 *
 * forme del @ingroup
 */
comment_unpublish_by_keyword_action_form di funzione ($context) {
  $form [“parole chiavi„] = allineamento (
    “#title„ => t (“parole chiavi "),
    => “textarea„ “del #type„,
    “#description„ => t (“il commento sarà non pubblicato se contiene c'è ne delle sequenze del carattere qui sopra. Usare una lista virgola-separata delle sequenze del carattere. Esempio: divertente, ammortizzatore ausiliario che salta, “Company, Inc.„. Le sequenze del carattere sono contenitore-sensitive."),
     drupal_implode_tags ($context [“parole chiavi„]): '',
  );
  $form di ritorno;
}

/**
 * Presentazioni trattate della forma del comment_unpublish_by_keyword_action_form.
 */
comment_unpublish_by_keyword_action_submit di funzione ($form, $form_state) {
  ;
}

/**
 * Esecuzione di un'azione configurabile di Drupal.
 * Unpublish un commento se contiene una determinata stringa.
 *
 * @param $context
 * Un allineamento che fornisce più informazioni sul contesto della chiamata a questa azione.
 * Inutilizzato qui poiché questa azione attualmente sostiene soltanto i ops dell'aggiornamento e dell'inserto di
 * il gancio di commento, di cui tutt'e due fornisce un oggetto completo di $comment.
 * @param $comment
 * Un oggetto di commento.
 */
comment_unpublish_by_keyword_action di funzione ($comment, $context) {
  foreach ($context [“parole chiavi„] come $keyword) {
    se (strstr ($comment->comment, $keyword) || strstr ($comment->subject, $keyword)) {
      db_query (“l'AGGIORNAMENTO {osservazioni} HA REGOLATO la condizione = %d DOVE cid = %d„, COMMENT_NOT_PUBLISHED, $comment->cid);
      cane da guardia (“azione„, “commento non pubblicato %subject. „, allineamento (=> $comment->subject “di %subject„));
      rottura;
    }
  }
}
class= > " libero " del
> " del codeSnippet " del class= del
class= " lineNumbers " del
class= del 
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:
class= " del id= " codeSnippet651348 del 
 $Id: comment.js, v 1.5 2007/09/12 di 18:29: 32 goba Exp $

Drupal.behaviors.com ment = funzione (contesto) {
  la varietà parte = nuovo allineamento (“nome„, “homepage„, “posta„);
  biscotto di varietà = '';
  per (i=0; i<3; i++) {
    biscotto = Drupal.com ment.getCookie (“comment_info_„ + parti [i]);
    se (biscotto! = '') {
      $("#comment-form immesso [name=„ + parte [i] +„]: non (.comment-processed) “, contesto)
        .val (biscotto)
        .addClass (“commentare-procedato ");
    }
  }
};

Drupal.com ment = {};

Drupal.com ment.getCookie = funzione (nome) {
  ricerca = nome di varietà + “=„;
  returnValue di varietà = '';

  se (document.cookie.length > 0) {
    contrappeso = document.cookie.indexOf (ricerca);
    se (sfalsare! = -1) {
      += di derivazione search.length;
      estremità di varietà = document.cookie.indexOf (“; „, contrappeso);
      se (== -1 dell'estremità) {
        estremità = document.cookie.length;
      }
      returnValue = decodeURIComponent (document.cookie.substring (sfalsare, estremità) .replace (/\ +/g, “%20„));
    }
  }

  restituire il returnValue;
};
class= del

Risposta : Come posso modificare il modulo di commento di Drupal in modo che non comprenda un campo del homepage?

Ha trovato che questa soluzione sulla tribuna e sull'esso di Drupal ha funzionato per me.

La copia ed incolla questo codice nella lima di template.php del vostro tema che sostituisce THEMENAME con il nome del vostro tema.

/**
* Esecuzione di HOOK_theme ().
*/
funzione THEMENAME_theme () {
allineamento di ritorno (
allineamento del => “del comment_form„ (                      
      allineamento del => “di discussioni„ (POSIZIONE DI SEGNALE MINIMO del => “della forma„),
    ),
  );
}

Ricordar che potete soltanto avere un caso di HOOK_theme nella vostra lima di mascherina in modo da unire questo con vostra esistente.

Allora inserire questa parte del codice qui sotto e cambiare THEMENAME al nome del vostro tema:

tema di // la forma di commento
funzione THEMENAME_comment_form ($form) {
  // rimuove il campo del homepage
  unset ($form [“homepage„]);          
  drupal_render di ritorno ($form);
}
Altre soluzioni  
 
programming4us programming4us