PageRenderTime 73ms CodeModel.GetById 34ms RepoModel.GetById 1ms app.codeStats 0ms

/wp-includes/theme.php

https://bitbucket.org/Thane2376/death-edge.ru
PHP | 2014 lines | 979 code | 250 blank | 785 comment | 249 complexity | 1d5813ae36183214a6cdf74f5080ae91 MD5 | raw file
Possible License(s): LGPL-2.1, GPL-2.0, LGPL-3.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

    

  1. <?php

    2. 

  2. /**

    3. 

  3.  * Theme, template, and stylesheet functions.

    4. 

  4.  *

    5. 

  5.  * @package WordPress

    6. 

  6.  * @subpackage Theme

    7. 

  7.  */

    8. 

  8. 

    9. 

  9. /**

    10. 

  10.  * Returns an array of WP_Theme objects based on the arguments.

    11. 

  11.  *

    12. 

  12.  * Despite advances over get_themes(), this function is quite expensive, and grows

    13. 

  13.  * linearly with additional themes. Stick to wp_get_theme() if possible.

    14. 

  14.  *

    15. 

  15.  * @since 3.4.0

    16. 

  16.  *

    17. 

  17.  * @param array $args The search arguments. Optional.

    18. 

  18.  * - errors      mixed  True to return themes with errors, false to return themes without errors, null

    19. 

  19.  *                      to return all themes. Defaults to false.

    20. 

  20.  * - allowed     mixed  (Multisite) True to return only allowed themes for a site. False to return only

    21. 

  21.  *                      disallowed themes for a site. 'site' to return only site-allowed themes. 'network'

    22. 

  22.  *                      to return only network-allowed themes. Null to return all themes. Defaults to null.

    23. 

  23.  * - blog_id     int    (Multisite) The blog ID used to calculate which themes are allowed. Defaults to 0,

    24. 

  24.  *                      synonymous for the current blog.

    25. 

  25.  * @return Array of WP_Theme objects.

    26. 

  26.  */

    27. 

  27. function wp_get_themes( $args = array() ) {

    28. 

  28. 	global $wp_theme_directories;

    29. 

  29. 

    30. 

  30. 	$defaults = array( 'errors' => false, 'allowed' => null, 'blog_id' => 0 );

    31. 

  31. 	$args = wp_parse_args( $args, $defaults );

    32. 

  32. 

    33. 

  33. 	$theme_directories = search_theme_directories();

    34. 

  34. 

    35. 

  35. 	if ( count( $wp_theme_directories ) > 1 ) {

    36. 

  36. 		// Make sure the current theme wins out, in case search_theme_directories() picks the wrong

    37. 

  37. 		// one in the case of a conflict. (Normally, last registered theme root wins.)

    38. 

  38. 		$current_theme = get_stylesheet();

    39. 

  39. 		if ( isset( $theme_directories[ $current_theme ] ) ) {

    40. 

  40. 			$root_of_current_theme = get_raw_theme_root( $current_theme );

    41. 

  41. 			if ( ! in_array( $root_of_current_theme, $wp_theme_directories ) )

    42. 

  42. 				$root_of_current_theme = WP_CONTENT_DIR . $root_of_current_theme;

    43. 

  43. 			$theme_directories[ $current_theme ]['theme_root'] = $root_of_current_theme;

    44. 

  44. 		}

    45. 

  45. 	}

    46. 

  46. 

    47. 

  47. 	if ( empty( $theme_directories ) )

    48. 

  48. 		return array();

    49. 

  49. 

    50. 

  50. 	if ( is_multisite() && null !== $args['allowed'] ) {

    51. 

  51. 		$allowed = $args['allowed'];

    52. 

  52. 		if ( 'network' === $allowed )

    53. 

  53. 			$theme_directories = array_intersect_key( $theme_directories, WP_Theme::get_allowed_on_network() );

    54. 

  54. 		elseif ( 'site' === $allowed )

    55. 

  55. 			$theme_directories = array_intersect_key( $theme_directories, WP_Theme::get_allowed_on_site( $args['blog_id'] ) );

    56. 

  56. 		elseif ( $allowed )

    57. 

  57. 			$theme_directories = array_intersect_key( $theme_directories, WP_Theme::get_allowed( $args['blog_id'] ) );

    58. 

  58. 		else

    59. 

  59. 			$theme_directories = array_diff_key( $theme_directories, WP_Theme::get_allowed( $args['blog_id'] ) );

    60. 

  60. 	}

    61. 

  61. 

    62. 

  62. 	$themes = array();

    63. 

  63. 	static $_themes = array();

    64. 

  64. 

    65. 

  65. 	foreach ( $theme_directories as $theme => $theme_root ) {

    66. 

  66. 		if ( isset( $_themes[ $theme_root['theme_root'] . '/' . $theme ] ) )

    67. 

  67. 			$themes[ $theme ] = $_themes[ $theme_root['theme_root'] . '/' . $theme ];

    68. 

  68. 		else

    69. 

  69. 			$themes[ $theme ] = $_themes[ $theme_root['theme_root'] . '/' . $theme ] = new WP_Theme( $theme, $theme_root['theme_root'] );

    70. 

  70. 	}

    71. 

  71. 

    72. 

  72. 	if ( null !== $args['errors'] ) {

    73. 

  73. 		foreach ( $themes as $theme => $wp_theme ) {

    74. 

  74. 			if ( $wp_theme->errors() != $args['errors'] )

    75. 

  75. 				unset( $themes[ $theme ] );

    76. 

  76. 		}

    77. 

  77. 	}

    78. 

  78. 

    79. 

  79. 	return $themes;

    80. 

  80. }

    81. 

  81. 

    82. 

  82. /**

    83. 

  83.  * Gets a WP_Theme object for a theme.

    84. 

  84.  *

    85. 

  85.  * @since 3.4.0

    86. 

  86.  *

    87. 

  87.  * @param string $stylesheet Directory name for the theme. Optional. Defaults to current theme.

    88. 

  88.  * @param string $theme_root Absolute path of the theme root to look in. Optional. If not specified, get_raw_theme_root()

    89. 

  89.  * 	is used to calculate the theme root for the $stylesheet provided (or current theme).

    90. 

  90.  * @return WP_Theme Theme object. Be sure to check the object's exists() method if you need to confirm the theme's existence.

    91. 

  91.  */

    92. 

  92. function wp_get_theme( $stylesheet = null, $theme_root = null ) {

    93. 

  93. 	global $wp_theme_directories;

    94. 

  94. 

    95. 

  95. 	if ( empty( $stylesheet ) )

    96. 

  96. 		$stylesheet = get_stylesheet();

    97. 

  97. 

    98. 

  98. 	if ( empty( $theme_root ) ) {

    99. 

  99. 		$theme_root = get_raw_theme_root( $stylesheet );

    100. 

  100. 		if ( false === $theme_root )

    101. 

  101. 			$theme_root = WP_CONTENT_DIR . '/themes';

    102. 

  102. 		elseif ( ! in_array( $theme_root, (array) $wp_theme_directories ) )

    103. 

  103. 			$theme_root = WP_CONTENT_DIR . $theme_root;

    104. 

  104. 	}

    105. 

  105. 

    106. 

  106. 	return new WP_Theme( $stylesheet, $theme_root );

    107. 

  107. }

    108. 

  108. 

    109. 

  109. /**

    110. 

  110.  * Clears the cache held by get_theme_roots() and WP_Theme.

    111. 

  111.  *

    112. 

  112.  * @since 3.5.0

    113. 

  113.  * @param bool $clear_update_cache Whether to clear the Theme updates cache

    114. 

  114.  */

    115. 

  115. function wp_clean_themes_cache( $clear_update_cache = true ) {

    116. 

  116. 	if ( $clear_update_cache )

    117. 

  117. 		delete_site_transient( 'update_themes' );

    118. 

  118. 	search_theme_directories( true );

    119. 

  119. 	foreach ( wp_get_themes( array( 'errors' => null ) ) as $theme )

    120. 

  120. 		$theme->cache_delete();

    121. 

  121. }

    122. 

  122. 

    123. 

  123. /**

    124. 

  124.  * Whether a child theme is in use.

    125. 

  125.  *

    126. 

  126.  * @since 3.0.0

    127. 

  127.  *

    128. 

  128.  * @return bool true if a child theme is in use, false otherwise.

    129. 

  129.  **/

    130. 

  130. function is_child_theme() {

    131. 

  131. 	return ( TEMPLATEPATH !== STYLESHEETPATH );

    132. 

  132. }

    133. 

  133. 

    134. 

  134. /**

    135. 

  135.  * Retrieve name of the current stylesheet.

    136. 

  136.  *

    137. 

  137.  * The theme name that the administrator has currently set the front end theme

    138. 

  138.  * as.

    139. 

  139.  *

    140. 

  140.  * For all intents and purposes, the template name and the stylesheet name are

    141. 

  141.  * going to be the same for most cases.

    142. 

  142.  *

    143. 

  143.  * @since 1.5.0

    144. 

  144.  *

    145. 

  145.  * @return string Stylesheet name.

    146. 

  146.  */

    147. 

  147. function get_stylesheet() {

    148. 

  148. 	/**

    149. 

  149. 	 * Filter the name of current stylesheet.

    150. 

  150. 	 *

    151. 

  151. 	 * @since 1.5.0

    152. 

  152. 	 *

    153. 

  153. 	 * @param string $stylesheet Name of the current stylesheet.

    154. 

  154. 	 */

    155. 

  155. 	return apply_filters( 'stylesheet', get_option( 'stylesheet' ) );

    156. 

  156. }

    157. 

  157. 

    158. 

  158. /**

    159. 

  159.  * Retrieve stylesheet directory path for current theme.

    160. 

  160.  *

    161. 

  161.  * @since 1.5.0

    162. 

  162.  *

    163. 

  163.  * @return string Path to current theme directory.

    164. 

  164.  */

    165. 

  165. function get_stylesheet_directory() {

    166. 

  166. 	$stylesheet = get_stylesheet();

    167. 

  167. 	$theme_root = get_theme_root( $stylesheet );

    168. 

  168. 	$stylesheet_dir = "$theme_root/$stylesheet";

    169. 

  169. 

    170. 

  170. 	/**

    171. 

  171. 	 * Filter the stylesheet directory path for current theme.

    172. 

  172. 	 *

    173. 

  173. 	 * @since 1.5.0

    174. 

  174. 	 *

    175. 

  175. 	 * @param string $stylesheet_dir Absolute path to the current them.

    176. 

  176. 	 * @param string $stylesheet     Directory name of the current theme.

    177. 

  177. 	 * @param string $theme_root     Absolute path to themes directory.

    178. 

  178. 	 */

    179. 

  179. 	return apply_filters( 'stylesheet_directory', $stylesheet_dir, $stylesheet, $theme_root );

    180. 

  180. }

    181. 

  181. 

    182. 

  182. /**

    183. 

  183.  * Retrieve stylesheet directory URI.

    184. 

  184.  *

    185. 

  185.  * @since 1.5.0

    186. 

  186.  *

    187. 

  187.  * @return string

    188. 

  188.  */

    189. 

  189. function get_stylesheet_directory_uri() {

    190. 

  190. 	$stylesheet = str_replace( '%2F', '/', rawurlencode( get_stylesheet() ) );

    191. 

  191. 	$theme_root_uri = get_theme_root_uri( $stylesheet );

    192. 

  192. 	$stylesheet_dir_uri = "$theme_root_uri/$stylesheet";

    193. 

  193. 

    194. 

  194. 	/**

    195. 

  195. 	 * Filter the stylesheet directory URI.

    196. 

  196. 	 *

    197. 

  197. 	 * @since 1.5.0

    198. 

  198. 	 *

    199. 

  199. 	 * @param string $stylesheet_dir_uri Stylesheet directory URI.

    200. 

  200. 	 * @param string $stylesheet         Name of the activated theme's directory.

    201. 

  201. 	 * @param string $theme_root_uri     Themes root URI.

    202. 

  202. 	 */

    203. 

  203. 	return apply_filters( 'stylesheet_directory_uri', $stylesheet_dir_uri, $stylesheet, $theme_root_uri );

    204. 

  204. }

    205. 

  205. 

    206. 

  206. /**

    207. 

  207.  * Retrieve URI of current theme stylesheet.

    208. 

  208.  *

    209. 

  209.  * The stylesheet file name is 'style.css' which is appended to {@link

    210. 

  210.  * get_stylesheet_directory_uri() stylesheet directory URI} path.

    211. 

  211.  *

    212. 

  212.  * @since 1.5.0

    213. 

  213.  *

    214. 

  214.  * @return string

    215. 

  215.  */

    216. 

  216. function get_stylesheet_uri() {

    217. 

  217. 	$stylesheet_dir_uri = get_stylesheet_directory_uri();

    218. 

  218. 	$stylesheet_uri = $stylesheet_dir_uri . '/style.css';

    219. 

  219. 	/**

    220. 

  220. 	 * Filter the URI of the current theme stylesheet.

    221. 

  221. 	 *

    222. 

  222. 	 * @since 1.5.0

    223. 

  223. 	 *

    224. 

  224. 	 * @param string $stylesheet_uri     Stylesheet URI for the current theme/child theme.

    225. 

  225. 	 * @param string $stylesheet_dir_uri Stylesheet directory URI for the current theme/child theme.

    226. 

  226. 	 */

    227. 

  227. 	return apply_filters( 'stylesheet_uri', $stylesheet_uri, $stylesheet_dir_uri );

    228. 

  228. }

    229. 

  229. 

    230. 

  230. /**

    231. 

  231.  * Retrieve localized stylesheet URI.

    232. 

  232.  *

    233. 

  233.  * The stylesheet directory for the localized stylesheet files are located, by

    234. 

  234.  * default, in the base theme directory. The name of the locale file will be the

    235. 

  235.  * locale followed by '.css'. If that does not exist, then the text direction

    236. 

  236.  * stylesheet will be checked for existence, for example 'ltr.css'.

    237. 

  237.  *

    238. 

  238.  * The theme may change the location of the stylesheet directory by either using

    239. 

  239.  * the 'stylesheet_directory_uri' filter or the 'locale_stylesheet_uri' filter.

    240. 

  240.  * If you want to change the location of the stylesheet files for the entire

    241. 

  241.  * WordPress workflow, then change the former. If you just have the locale in a

    242. 

  242.  * separate folder, then change the latter.

    243. 

  243.  *

    244. 

  244.  * @since 2.1.0

    245. 

  245.  *

    246. 

  246.  * @return string

    247. 

  247.  */

    248. 

  248. function get_locale_stylesheet_uri() {

    249. 

  249. 	global $wp_locale;

    250. 

  250. 	$stylesheet_dir_uri = get_stylesheet_directory_uri();

    251. 

  251. 	$dir = get_stylesheet_directory();

    252. 

  252. 	$locale = get_locale();

    253. 

  253. 	if ( file_exists("$dir/$locale.css") )

    254. 

  254. 		$stylesheet_uri = "$stylesheet_dir_uri/$locale.css";

    255. 

  255. 	elseif ( !empty($wp_locale->text_direction) && file_exists("$dir/{$wp_locale->text_direction}.css") )

    256. 

  256. 		$stylesheet_uri = "$stylesheet_dir_uri/{$wp_locale->text_direction}.css";

    257. 

  257. 	else

    258. 

  258. 		$stylesheet_uri = '';

    259. 

  259. 	/**

    260. 

  260. 	 * Filter the localized stylesheet URI.

    261. 

  261. 	 *

    262. 

  262. 	 * @since 2.1.0

    263. 

  263. 	 *

    264. 

  264. 	 * @param string $stylesheet_uri     Localized stylesheet URI.

    265. 

  265. 	 * @param string $stylesheet_dir_uri Stylesheet directory URI.

    266. 

  266. 	 */

    267. 

  267. 	return apply_filters( 'locale_stylesheet_uri', $stylesheet_uri, $stylesheet_dir_uri );

    268. 

  268. }

    269. 

  269. 

    270. 

  270. /**

    271. 

  271.  * Retrieve name of the current theme.

    272. 

  272.  *

    273. 

  273.  * @since 1.5.0

    274. 

  274.  * @uses apply_filters() Calls 'template' filter on template option.

    275. 

  275.  *

    276. 

  276.  * @return string Template name.

    277. 

  277.  */

    278. 

  278. function get_template() {

    279. 

  279. 	/**

    280. 

  280. 	 * Filter the name of the current theme.

    281. 

  281. 	 *

    282. 

  282. 	 * @since 1.5.0

    283. 

  283. 	 *

    284. 

  284. 	 * @param string $template Current theme's directory name.

    285. 

  285. 	 */

    286. 

  286. 	return apply_filters( 'template', get_option( 'template' ) );

    287. 

  287. }

    288. 

  288. 

    289. 

  289. /**

    290. 

  290.  * Retrieve current theme directory.

    291. 

  291.  *

    292. 

  292.  * @since 1.5.0

    293. 

  293.  *

    294. 

  294.  * @return string Template directory path.

    295. 

  295.  */

    296. 

  296. function get_template_directory() {

    297. 

  297. 	$template = get_template();

    298. 

  298. 	$theme_root = get_theme_root( $template );

    299. 

  299. 	$template_dir = "$theme_root/$template";

    300. 

  300. 

    301. 

  301. 	/**

    302. 

  302. 	 * Filter the current theme directory path.

    303. 

  303. 	 *

    304. 

  304. 	 * @since 1.5.0

    305. 

  305. 	 *

    306. 

  306. 	 * @param string $template_dir The URI of the current theme directory.

    307. 

  307. 	 * @param string $template     Directory name of the current theme.

    308. 

  308. 	 * @param string $theme_root   Absolute path to the themes directory.

    309. 

  309. 	 */

    310. 

  310. 	return apply_filters( 'template_directory', $template_dir, $template, $theme_root );

    311. 

  311. }

    312. 

  312. 

    313. 

  313. /**

    314. 

  314.  * Retrieve theme directory URI.

    315. 

  315.  *

    316. 

  316.  * @since 1.5.0

    317. 

  317.  *

    318. 

  318.  * @return string Template directory URI.

    319. 

  319.  */

    320. 

  320. function get_template_directory_uri() {

    321. 

  321. 	$template = str_replace( '%2F', '/', rawurlencode( get_template() ) );

    322. 

  322. 	$theme_root_uri = get_theme_root_uri( $template );

    323. 

  323. 	$template_dir_uri = "$theme_root_uri/$template";

    324. 

  324. 

    325. 

  325. 	/**

    326. 

  326. 	 * Filter the current theme directory URI.

    327. 

  327. 	 *

    328. 

  328. 	 * @since 1.5.0

    329. 

  329. 	 *

    330. 

  330. 	 * @param string $template_dir_uri The URI of the current theme directory.

    331. 

  331. 	 * @param string $template         Directory name of the current theme.

    332. 

  332. 	 * @param string $theme_root_uri   The themes root URI.

    333. 

  333. 	 */

    334. 

  334. 	return apply_filters( 'template_directory_uri', $template_dir_uri, $template, $theme_root_uri );

    335. 

  335. }

    336. 

  336. 

    337. 

  337. /**

    338. 

  338.  * Retrieve theme roots.

    339. 

  339.  *

    340. 

  340.  * @since 2.9.0

    341. 

  341.  *

    342. 

  342.  * @return array|string An array of theme roots keyed by template/stylesheet or a single theme root if all themes have the same root.

    343. 

  343.  */

    344. 

  344. function get_theme_roots() {

    345. 

  345. 	global $wp_theme_directories;

    346. 

  346. 

    347. 

  347. 	if ( count($wp_theme_directories) <= 1 )

    348. 

  348. 		return '/themes';

    349. 

  349. 

    350. 

  350. 	$theme_roots = get_site_transient( 'theme_roots' );

    351. 

  351. 	if ( false === $theme_roots ) {

    352. 

  352. 		search_theme_directories( true ); // Regenerate the transient.

    353. 

  353. 		$theme_roots = get_site_transient( 'theme_roots' );

    354. 

  354. 	}

    355. 

  355. 	return $theme_roots;

    356. 

  356. }

    357. 

  357. 

    358. 

  358. /**

    359. 

  359.  * Register a directory that contains themes.

    360. 

  360.  *

    361. 

  361.  * @since 2.9.0

    362. 

  362.  *

    363. 

  363.  * @param string $directory Either the full filesystem path to a theme folder or a folder within WP_CONTENT_DIR

    364. 

  364.  * @return bool

    365. 

  365.  */

    366. 

  366. function register_theme_directory( $directory ) {

    367. 

  367. 	global $wp_theme_directories;

    368. 

  368. 

    369. 

  369. 	if ( ! file_exists( $directory ) ) {

    370. 

  370. 		// Try prepending as the theme directory could be relative to the content directory

    371. 

  371. 		$directory = WP_CONTENT_DIR . '/' . $directory;

    372. 

  372. 		// If this directory does not exist, return and do not register

    373. 

  373. 		if ( ! file_exists( $directory ) ) {

    374. 

  374. 			return false;

    375. 

  375. 		}

    376. 

  376. 	}

    377. 

  377. 

    378. 

  378. 	if ( ! is_array( $wp_theme_directories ) ) {

    379. 

  379. 		$wp_theme_directories = array();

    380. 

  380. 	}

    381. 

  381. 

    382. 

  382. 	$untrailed = untrailingslashit( $directory );

    383. 

  383. 	if ( ! empty( $untrailed ) && ! in_array( $untrailed, $wp_theme_directories ) ) {

    384. 

  384. 		$wp_theme_directories[] = $untrailed;

    385. 

  385. 	}

    386. 

  386. 

    387. 

  387. 	return true;

    388. 

  388. }

    389. 

  389. 

    390. 

  390. /**

    391. 

  391.  * Search all registered theme directories for complete and valid themes.

    392. 

  392.  *

    393. 

  393.  * @since 2.9.0

    394. 

  394.  *

    395. 

  395.  * @param bool $force Optional. Whether to force a new directory scan. Defaults to false.

    396. 

  396.  * @return array Valid themes found

    397. 

  397.  */

    398. 

  398. function search_theme_directories( $force = false ) {

    399. 

  399. 	global $wp_theme_directories;

    400. 

  400. 	if ( empty( $wp_theme_directories ) )

    401. 

  401. 		return false;

    402. 

  402. 

    403. 

  403. 	static $found_themes;

    404. 

  404. 	if ( ! $force && isset( $found_themes ) )

    405. 

  405. 		return $found_themes;

    406. 

  406. 

    407. 

  407. 	$found_themes = array();

    408. 

  408. 

    409. 

  409. 	$wp_theme_directories = (array) $wp_theme_directories;

    410. 

  410. 

    411. 

  411. 	// Set up maybe-relative, maybe-absolute array of theme directories.

    412. 

  412. 	// We always want to return absolute, but we need to cache relative

    413. 

  413. 	// to use in get_theme_root().

    414. 

  414. 	foreach ( $wp_theme_directories as $theme_root ) {

    415. 

  415. 		if ( 0 === strpos( $theme_root, WP_CONTENT_DIR ) )

    416. 

  416. 			$relative_theme_roots[ str_replace( WP_CONTENT_DIR, '', $theme_root ) ] = $theme_root;

    417. 

  417. 		else

    418. 

  418. 			$relative_theme_roots[ $theme_root ] = $theme_root;

    419. 

  419. 	}

    420. 

  420. 

    421. 

  421. 	/**

    422. 

  422. 	 * Filter whether to get the cache of the registered theme directories.

    423. 

  423. 	 *

    424. 

  424. 	 * @since 3.4.0

    425. 

  425. 	 *

    426. 

  426. 	 * @param bool   $cache_expiration Whether to get the cache of the theme directories. Default false.

    427. 

  427. 	 * @param string $cache_directory  Directory to be searched for the cache.

    428. 

  428. 	 */

    429. 

  429. 	if ( $cache_expiration = apply_filters( 'wp_cache_themes_persistently', false, 'search_theme_directories' ) ) {

    430. 

  430. 		$cached_roots = get_site_transient( 'theme_roots' );

    431. 

  431. 		if ( is_array( $cached_roots ) ) {

    432. 

  432. 			foreach ( $cached_roots as $theme_dir => $theme_root ) {

    433. 

  433. 				// A cached theme root is no longer around, so skip it.

    434. 

  434. 				if ( ! isset( $relative_theme_roots[ $theme_root ] ) )

    435. 

  435. 					continue;

    436. 

  436. 				$found_themes[ $theme_dir ] = array(

    437. 

  437. 					'theme_file' => $theme_dir . '/style.css',

    438. 

  438. 					'theme_root' => $relative_theme_roots[ $theme_root ], // Convert relative to absolute.

    439. 

  439. 				);

    440. 

  440. 			}

    441. 

  441. 			return $found_themes;

    442. 

  442. 		}

    443. 

  443. 		if ( ! is_int( $cache_expiration ) )

    444. 

  444. 			$cache_expiration = 1800; // half hour

    445. 

  445. 	} else {

    446. 

  446. 		$cache_expiration = 1800; // half hour

    447. 

  447. 	}

    448. 

  448. 

    449. 

  449. 	/* Loop the registered theme directories and extract all themes */

    450. 

  450. 	foreach ( $wp_theme_directories as $theme_root ) {

    451. 

  451. 

    452. 

  452. 		// Start with directories in the root of the current theme directory.

    453. 

  453. 		$dirs = @ scandir( $theme_root );

    454. 

  454. 		if ( ! $dirs ) {

    455. 

  455. 			trigger_error( "$theme_root is not readable", E_USER_NOTICE );

    456. 

  456. 			continue;

    457. 

  457. 		}

    458. 

  458. 		foreach ( $dirs as $dir ) {

    459. 

  459. 			if ( ! is_dir( $theme_root . '/' . $dir ) || $dir[0] == '.' || $dir == 'CVS' )

    460. 

  460. 				continue;

    461. 

  461. 			if ( file_exists( $theme_root . '/' . $dir . '/style.css' ) ) {

    462. 

  462. 				// wp-content/themes/a-single-theme

    463. 

  463. 				// wp-content/themes is $theme_root, a-single-theme is $dir

    464. 

  464. 				$found_themes[ $dir ] = array(

    465. 

  465. 					'theme_file' => $dir . '/style.css',

    466. 

  466. 					'theme_root' => $theme_root,

    467. 

  467. 				);

    468. 

  468. 			} else {

    469. 

  469. 				$found_theme = false;

    470. 

  470. 				// wp-content/themes/a-folder-of-themes/*

    471. 

  471. 				// wp-content/themes is $theme_root, a-folder-of-themes is $dir, then themes are $sub_dirs

    472. 

  472. 				$sub_dirs = @ scandir( $theme_root . '/' . $dir );

    473. 

  473. 				if ( ! $sub_dirs ) {

    474. 

  474. 					trigger_error( "$theme_root/$dir is not readable", E_USER_NOTICE );

    475. 

  475. 					continue;

    476. 

  476. 				}

    477. 

  477. 				foreach ( $sub_dirs as $sub_dir ) {

    478. 

  478. 					if ( ! is_dir( $theme_root . '/' . $dir . '/' . $sub_dir ) || $dir[0] == '.' || $dir == 'CVS' )

    479. 

  479. 						continue;

    480. 

  480. 					if ( ! file_exists( $theme_root . '/' . $dir . '/' . $sub_dir . '/style.css' ) )

    481. 

  481. 						continue;

    482. 

  482. 					$found_themes[ $dir . '/' . $sub_dir ] = array(

    483. 

  483. 						'theme_file' => $dir . '/' . $sub_dir . '/style.css',

    484. 

  484. 						'theme_root' => $theme_root,

    485. 

  485. 					);

    486. 

  486. 					$found_theme = true;

    487. 

  487. 				}

    488. 

  488. 				// Never mind the above, it's just a theme missing a style.css.

    489. 

  489. 				// Return it; WP_Theme will catch the error.

    490. 

  490. 				if ( ! $found_theme )

    491. 

  491. 					$found_themes[ $dir ] = array(

    492. 

  492. 						'theme_file' => $dir . '/style.css',

    493. 

  493. 						'theme_root' => $theme_root,

    494. 

  494. 					);

    495. 

  495. 			}

    496. 

  496. 		}

    497. 

  497. 	}

    498. 

  498. 

    499. 

  499. 	asort( $found_themes );

    500. 

  500. 

    501. 

  501. 	$theme_roots = array();

    502. 

  502. 	$relative_theme_roots = array_flip( $relative_theme_roots );

    503. 

  503. 

    504. 

  504. 	foreach ( $found_themes as $theme_dir => $theme_data ) {

    505. 

  505. 		$theme_roots[ $theme_dir ] = $relative_theme_roots[ $theme_data['theme_root'] ]; // Convert absolute to relative.

    506. 

  506. 	}

    507. 

  507. 

    508. 

  508. 	if ( $theme_roots != get_site_transient( 'theme_roots' ) )

    509. 

  509. 		set_site_transient( 'theme_roots', $theme_roots, $cache_expiration );

    510. 

  510. 

    511. 

  511. 	return $found_themes;

    512. 

  512. }

    513. 

  513. 

    514. 

  514. /**

    515. 

  515.  * Retrieve path to themes directory.

    516. 

  516.  *

    517. 

  517.  * Does not have trailing slash.

    518. 

  518.  *

    519. 

  519.  * @since 1.5.0

    520. 

  520.  *

    521. 

  521.  * @param string $stylesheet_or_template The stylesheet or template name of the theme

    522. 

  522.  * @return string Theme path.

    523. 

  523.  */

    524. 

  524. function get_theme_root( $stylesheet_or_template = false ) {

    525. 

  525. 	global $wp_theme_directories;

    526. 

  526. 

    527. 

  527. 	if ( $stylesheet_or_template && $theme_root = get_raw_theme_root( $stylesheet_or_template ) ) {

    528. 

  528. 		// Always prepend WP_CONTENT_DIR unless the root currently registered as a theme directory.

    529. 

  529. 		// This gives relative theme roots the benefit of the doubt when things go haywire.

    530. 

  530. 		if ( ! in_array( $theme_root, (array) $wp_theme_directories ) )

    531. 

  531. 			$theme_root = WP_CONTENT_DIR . $theme_root;

    532. 

  532. 	} else {

    533. 

  533. 		$theme_root = WP_CONTENT_DIR . '/themes';

    534. 

  534. 	}

    535. 

  535. 

    536. 

  536. 	/**

    537. 

  537. 	 * Filter the absolute path to the themes directory.

    538. 

  538. 	 *

    539. 

  539. 	 * @since 1.5.0

    540. 

  540. 	 *

    541. 

  541. 	 * @param string $theme_root Absolute path to themes directory.

    542. 

  542. 	 */

    543. 

  543. 	return apply_filters( 'theme_root', $theme_root );

    544. 

  544. }

    545. 

  545. 

    546. 

  546. /**

    547. 

  547.  * Retrieve URI for themes directory.

    548. 

  548.  *

    549. 

  549.  * Does not have trailing slash.

    550. 

  550.  *

    551. 

  551.  * @since 1.5.0

    552. 

  552.  *

    553. 

  553.  * @param string $stylesheet_or_template Optional. The stylesheet or template name of the theme.

    554. 

  554.  * 	Default is to leverage the main theme root.

    555. 

  555.  * @param string $theme_root Optional. The theme root for which calculations will be based, preventing

    556. 

  556.  * 	the need for a get_raw_theme_root() call.

    557. 

  557.  * @return string Themes URI.

    558. 

  558.  */

    559. 

  559. function get_theme_root_uri( $stylesheet_or_template = false, $theme_root = false ) {

    560. 

  560. 	global $wp_theme_directories;

    561. 

  561. 

    562. 

  562. 	if ( $stylesheet_or_template && ! $theme_root )

    563. 

  563. 		$theme_root = get_raw_theme_root( $stylesheet_or_template );

    564. 

  564. 

    565. 

  565. 	if ( $stylesheet_or_template && $theme_root ) {

    566. 

  566. 		if ( in_array( $theme_root, (array) $wp_theme_directories ) ) {

    567. 

  567. 			// Absolute path. Make an educated guess. YMMV -- but note the filter below.

    568. 

  568. 			if ( 0 === strpos( $theme_root, WP_CONTENT_DIR ) )

    569. 

  569. 				$theme_root_uri = content_url( str_replace( WP_CONTENT_DIR, '', $theme_root ) );

    570. 

  570. 			elseif ( 0 === strpos( $theme_root, ABSPATH ) )

    571. 

  571. 				$theme_root_uri = site_url( str_replace( ABSPATH, '', $theme_root ) );

    572. 

  572. 			elseif ( 0 === strpos( $theme_root, WP_PLUGIN_DIR ) || 0 === strpos( $theme_root, WPMU_PLUGIN_DIR ) )

    573. 

  573. 				$theme_root_uri = plugins_url( basename( $theme_root ), $theme_root );

    574. 

  574. 			else

    575. 

  575. 				$theme_root_uri = $theme_root;

    576. 

  576. 		} else {

    577. 

  577. 			$theme_root_uri = content_url( $theme_root );

    578. 

  578. 		}

    579. 

  579. 	} else {

    580. 

  580. 		$theme_root_uri = content_url( 'themes' );

    581. 

  581. 	}

    582. 

  582. 

    583. 

  583. 	/**

    584. 

  584. 	 * Filter the URI for themes directory.

    585. 

  585. 	 *

    586. 

  586. 	 * @since 1.5.0

    587. 

  587. 	 *

    588. 

  588. 	 * @param string $theme_root_uri         The URI for themes directory.

    589. 

  589. 	 * @param string $siteurl                WordPress web address which is set in General Options.

    590. 

  590. 	 * @param string $stylesheet_or_template Stylesheet or template name of the theme.

    591. 

  591. 	 */

    592. 

  592. 	return apply_filters( 'theme_root_uri', $theme_root_uri, get_option( 'siteurl' ), $stylesheet_or_template );

    593. 

  593. }

    594. 

  594. 

    595. 

  595. /**

    596. 

  596.  * Get the raw theme root relative to the content directory with no filters applied.

    597. 

  597.  *

    598. 

  598.  * @since 3.1.0

    599. 

  599.  *

    600. 

  600.  * @param string $stylesheet_or_template The stylesheet or template name of the theme

    601. 

  601.  * @param bool $skip_cache Optional. Whether to skip the cache. Defaults to false, meaning the cache is used.

    602. 

  602.  * @return string Theme root

    603. 

  603.  */

    604. 

  604. function get_raw_theme_root( $stylesheet_or_template, $skip_cache = false ) {

    605. 

  605. 	global $wp_theme_directories;

    606. 

  606. 

    607. 

  607. 	if ( count($wp_theme_directories) <= 1 )

    608. 

  608. 		return '/themes';

    609. 

  609. 

    610. 

  610. 	$theme_root = false;

    611. 

  611. 

    612. 

  612. 	// If requesting the root for the current theme, consult options to avoid calling get_theme_roots()

    613. 

  613. 	if ( ! $skip_cache ) {

    614. 

  614. 		if ( get_option('stylesheet') == $stylesheet_or_template )

    615. 

  615. 			$theme_root = get_option('stylesheet_root');

    616. 

  616. 		elseif ( get_option('template') == $stylesheet_or_template )

    617. 

  617. 			$theme_root = get_option('template_root');

    618. 

  618. 	}

    619. 

  619. 

    620. 

  620. 	if ( empty($theme_root) ) {

    621. 

  621. 		$theme_roots = get_theme_roots();

    622. 

  622. 		if ( !empty($theme_roots[$stylesheet_or_template]) )

    623. 

  623. 			$theme_root = $theme_roots[$stylesheet_or_template];

    624. 

  624. 	}

    625. 

  625. 

    626. 

  626. 	return $theme_root;

    627. 

  627. }

    628. 

  628. 

    629. 

  629. /**

    630. 

  630.  * Display localized stylesheet link element.

    631. 

  631.  *

    632. 

  632.  * @since 2.1.0

    633. 

  633.  */

    634. 

  634. function locale_stylesheet() {

    635. 

  635. 	$stylesheet = get_locale_stylesheet_uri();

    636. 

  636. 	if ( empty($stylesheet) )

    637. 

  637. 		return;

    638. 

  638. 	echo '<link rel="stylesheet" href="' . $stylesheet . '" type="text/css" media="screen" />';

    639. 

  639. }

    640. 

  640. 

    641. 

  641. /**

    642. 

  642.  * Start preview theme output buffer.

    643. 

  643.  *

    644. 

  644.  * Will only perform task if the user has permissions and template and preview

    645. 

  645.  * query variables exist.

    646. 

  646.  *

    647. 

  647.  * @since 2.6.0

    648. 

  648.  */

    649. 

  649. function preview_theme() {

    650. 

  650. 	if ( ! (isset($_GET['template']) && isset($_GET['preview'])) )

    651. 

  651. 		return;

    652. 

  652. 

    653. 

  653. 	if ( !current_user_can( 'switch_themes' ) )

    654. 

  654. 		return;

    655. 

  655. 

    656. 

  656. 	// Admin Thickbox requests

    657. 

  657. 	if ( isset( $_GET['preview_iframe'] ) )

    658. 

  658. 		show_admin_bar( false );

    659. 

  659. 

    660. 

  660. 	$_GET['template'] = preg_replace('|[^a-z0-9_./-]|i', '', $_GET['template']);

    661. 

  661. 

    662. 

  662. 	if ( validate_file($_GET['template']) )

    663. 

  663. 		return;

    664. 

  664. 

    665. 

  665. 	add_filter( 'template', '_preview_theme_template_filter' );

    666. 

  666. 

    667. 

  667. 	if ( isset($_GET['stylesheet']) ) {

    668. 

  668. 		$_GET['stylesheet'] = preg_replace('|[^a-z0-9_./-]|i', '', $_GET['stylesheet']);

    669. 

  669. 		if ( validate_file($_GET['stylesheet']) )

    670. 

  670. 			return;

    671. 

  671. 		add_filter( 'stylesheet', '_preview_theme_stylesheet_filter' );

    672. 

  672. 	}

    673. 

  673. 

    674. 

  674. 	// Prevent theme mods to current theme being used on theme being previewed

    675. 

  675. 	add_filter( 'pre_option_theme_mods_' . get_option( 'stylesheet' ), '__return_empty_array' );

    676. 

  676. 

    677. 

  677. 	ob_start( 'preview_theme_ob_filter' );

    678. 

  678. }

    679. 

  679. add_action('setup_theme', 'preview_theme');

    680. 

  680. 

    681. 

  681. /**

    682. 

  682.  * Private function to modify the current template when previewing a theme

    683. 

  683.  *

    684. 

  684.  * @since 2.9.0

    685. 

  685.  * @access private

    686. 

  686.  *

    687. 

  687.  * @return string

    688. 

  688.  */

    689. 

  689. function _preview_theme_template_filter() {

    690. 

  690. 	return isset($_GET['template']) ? $_GET['template'] : '';

    691. 

  691. }

    692. 

  692. 

    693. 

  693. /**

    694. 

  694.  * Private function to modify the current stylesheet when previewing a theme

    695. 

  695.  *

    696. 

  696.  * @since 2.9.0

    697. 

  697.  * @access private

    698. 

  698.  *

    699. 

  699.  * @return string

    700. 

  700.  */

    701. 

  701. function _preview_theme_stylesheet_filter() {

    702. 

  702. 	return isset($_GET['stylesheet']) ? $_GET['stylesheet'] : '';

    703. 

  703. }

    704. 

  704. 

    705. 

  705. /**

    706. 

  706.  * Callback function for ob_start() to capture all links in the theme.

    707. 

  707.  *

    708. 

  708.  * @since 2.6.0

    709. 

  709.  * @access private

    710. 

  710.  *

    711. 

  711.  * @param string $content

    712. 

  712.  * @return string

    713. 

  713.  */

    714. 

  714. function preview_theme_ob_filter( $content ) {

    715. 

  715. 	return preg_replace_callback( "|(<a.*?href=([\"']))(.*?)([\"'].*?>)|", 'preview_theme_ob_filter_callback', $content );

    716. 

  716. }

    717. 

  717. 

    718. 

  718. /**

    719. 

  719.  * Manipulates preview theme links in order to control and maintain location.

    720. 

  720.  *

    721. 

  721.  * Callback function for preg_replace_callback() to accept and filter matches.

    722. 

  722.  *

    723. 

  723.  * @since 2.6.0

    724. 

  724.  * @access private

    725. 

  725.  *

    726. 

  726.  * @param array $matches

    727. 

  727.  * @return string

    728. 

  728.  */

    729. 

  729. function preview_theme_ob_filter_callback( $matches ) {

    730. 

  730. 	if ( strpos($matches[4], 'onclick') !== false )

    731. 

  731. 		$matches[4] = preg_replace('#onclick=([\'"]).*?(?<!\\\)\\1#i', '', $matches[4]); //Strip out any onclicks from rest of <a>. (?<!\\\) means to ignore the '" if it's escaped by \  to prevent breaking mid-attribute.

    732. 

  732. 	if (

    733. 

  733. 		( false !== strpos($matches[3], '/wp-admin/') )

    734. 

  734. 	||

    735. 

  735. 		( false !== strpos( $matches[3], '://' ) && 0 !== strpos( $matches[3], home_url() ) )

    736. 

  736. 	||

    737. 

  737. 		( false !== strpos($matches[3], '/feed/') )

    738. 

  738. 	||

    739. 

  739. 		( false !== strpos($matches[3], '/trackback/') )

    740. 

  740. 	)

    741. 

  741. 		return $matches[1] . "#$matches[2] onclick=$matches[2]return false;" . $matches[4];

    742. 

  742. 

    743. 

  743. 	$stylesheet = isset( $_GET['stylesheet'] ) ? $_GET['stylesheet'] : '';

    744. 

  744. 	$template   = isset( $_GET['template'] )   ? $_GET['template']   : '';

    745. 

  745. 

    746. 

  746. 	$link = add_query_arg( array( 'preview' => 1, 'template' => $template, 'stylesheet' => $stylesheet, 'preview_iframe' => 1 ), $matches[3] );

    747. 

  747. 	if ( 0 === strpos($link, 'preview=1') )

    748. 

  748. 		$link = "?$link";

    749. 

  749. 	return $matches[1] . esc_attr( $link ) . $matches[4];

    750. 

  750. }

    751. 

  751. 

    752. 

  752. /**

    753. 

  753.  * Switches the theme.

    754. 

  754.  *

    755. 

  755.  * Accepts one argument: $stylesheet of the theme. It also accepts an additional function signature

    756. 

  756.  * of two arguments: $template then $stylesheet. This is for backwards compatibility.

    757. 

  757.  *

    758. 

  758.  * @since 2.5.0

    759. 

  759.  *

    760. 

  760.  * @param string $stylesheet Stylesheet name

    761. 

  761.  */

    762. 

  762. function switch_theme( $stylesheet ) {

    763. 

  763. 	global $wp_theme_directories, $wp_customize, $sidebars_widgets;

    764. 

  764. 

    765. 

  765. 	$_sidebars_widgets = null;

    766. 

  766. 	if ( 'wp_ajax_customize_save' === current_action() ) {

    767. 

  767. 		$_sidebars_widgets = $wp_customize->post_value( $wp_customize->get_setting( 'old_sidebars_widgets_data' ) );

    768. 

  768. 	} elseif ( is_array( $sidebars_widgets ) ) {

    769. 

  769. 		$_sidebars_widgets = $sidebars_widgets;

    770. 

  770. 	}

    771. 

  771. 

    772. 

  772. 	if ( is_array( $_sidebars_widgets ) ) {

    773. 

  773. 		set_theme_mod( 'sidebars_widgets', array( 'time' => time(), 'data' => $_sidebars_widgets ) );

    774. 

  774. 	}

    775. 

  775. 

    776. 

  776. 	$old_theme  = wp_get_theme();

    777. 

  777. 	$new_theme = wp_get_theme( $stylesheet );

    778. 

  778. 

    779. 

  779. 	if ( func_num_args() > 1 ) {

    780. 

  780. 		$template = $stylesheet;

    781. 

  781. 		$stylesheet = func_get_arg( 1 );

    782. 

  782. 	} else {

    783. 

  783. 		$template = $new_theme->get_template();

    784. 

  784. 	}

    785. 

  785. 

    786. 

  786. 	update_option( 'template', $template );

    787. 

  787. 	update_option( 'stylesheet', $stylesheet );

    788. 

  788. 

    789. 

  789. 	if ( count( $wp_theme_directories ) > 1 ) {

    790. 

  790. 		update_option( 'template_root', get_raw_theme_root( $template, true ) );

    791. 

  791. 		update_option( 'stylesheet_root', get_raw_theme_root( $stylesheet, true ) );

    792. 

  792. 	} else {

    793. 

  793. 		delete_option( 'template_root' );

    794. 

  794. 		delete_option( 'stylesheet_root' );

    795. 

  795. 	}

    796. 

  796. 

    797. 

  797. 	$new_name  = $new_theme->get('Name');

    798. 

  798. 

    799. 

  799. 	update_option( 'current_theme', $new_name );

    800. 

  800. 

    801. 

  801. 	// Migrate from the old mods_{name} option to theme_mods_{slug}.

    802. 

  802. 	if ( is_admin() && false === get_option( 'theme_mods_' . $stylesheet ) ) {

    803. 

  803. 		$default_theme_mods = (array) get_option( 'mods_' . $new_name );

    804. 

  804. 		add_option( "theme_mods_$stylesheet", $default_theme_mods );

    805. 

  805. 	} else {

    806. 

  806. 		/*

    807. 

  807. 		 * Since retrieve_widgets() is called when initializing the customizer theme,

    808. 

  808. 		 * we need to to remove the theme mods to avoid overwriting changes made via

    809. 

  809. 		 * the widget customizer when accessing wp-admin/widgets.php.

    810. 

  810. 		 */

    811. 

  811. 		if ( 'wp_ajax_customize_save' === current_action() ) {

    812. 

  812. 			remove_theme_mod( 'sidebars_widgets' );

    813. 

  813. 		}

    814. 

  814. 	}

    815. 

  815. 

    816. 

  816. 	update_option( 'theme_switched', $old_theme->get_stylesheet() );

    817. 

  817. 	/**

    818. 

  818. 	 * Fires after the theme is switched.

    819. 

  819. 	 *

    820. 

  820. 	 * @since 1.5.0

    821. 

  821. 	 *

    822. 

  822. 	 * @param string   $new_name  Name of the new theme.

    823. 

  823. 	 * @param WP_Theme $new_theme WP_Theme instance of the new theme.

    824. 

  824. 	 */

    825. 

  825. 	do_action( 'switch_theme', $new_name, $new_theme );

    826. 

  826. }

    827. 

  827. 

    828. 

  828. /**

    829. 

  829.  * Checks that current theme files 'index.php' and 'style.css' exists.

    830. 

  830.  *

    831. 

  831.  * Does not check the default theme, which is the fallback and should always exist.

    832. 

  832.  * Will switch theme to the fallback theme if current theme does not validate.

    833. 

  833.  * You can use the 'validate_current_theme' filter to return false to

    834. 

  834.  * disable this functionality.

    835. 

  835.  *

    836. 

  836.  * @since 1.5.0

    837. 

  837.  * @see WP_DEFAULT_THEME

    838. 

  838.  *

    839. 

  839.  * @return bool

    840. 

  840.  */

    841. 

  841. function validate_current_theme() {

    842. 

  842. 	/**

    843. 

  843. 	 * Filter whether to validate the current theme.

    844. 

  844. 	 *

    845. 

  845. 	 * @since 2.7.0

    846. 

  846. 	 *

    847. 

  847. 	 * @param bool true Validation flag to check the current theme.

    848. 

  848. 	 */

    849. 

  849. 	if ( defined('WP_INSTALLING') || ! apply_filters( 'validate_current_theme', true ) )

    850. 

  850. 		return true;

    851. 

  851. 

    852. 

  852. 	if ( get_template() != WP_DEFAULT_THEME && !file_exists(get_template_directory() . '/index.php') ) {

    853. 

  853. 		switch_theme( WP_DEFAULT_THEME );

    854. 

  854. 		return false;

    855. 

  855. 	}

    856. 

  856. 

    857. 

  857. 	if ( get_stylesheet() != WP_DEFAULT_THEME && !file_exists(get_template_directory() . '/style.css') ) {

    858. 

  858. 		switch_theme( WP_DEFAULT_THEME );

    859. 

  859. 		return false;

    860. 

  860. 	}

    861. 

  861. 

    862. 

  862. 	if ( is_child_theme() && ! file_exists( get_stylesheet_directory() . '/style.css' ) ) {

    863. 

  863. 		switch_theme( WP_DEFAULT_THEME );

    864. 

  864. 		return false;

    865. 

  865. 	}

    866. 

  866. 

    867. 

  867. 	return true;

    868. 

  868. }

    869. 

  869. 

    870. 

  870. /**

    871. 

  871.  * Retrieve all theme modifications.

    872. 

  872.  *

    873. 

  873.  * @since 3.1.0

    874. 

  874.  *

    875. 

  875.  * @return array Theme modifications.

    876. 

  876.  */

    877. 

  877. function get_theme_mods() {

    878. 

  878. 	$theme_slug = get_option( 'stylesheet' );

    879. 

  879. 	if ( false === ( $mods = get_option( "theme_mods_$theme_slug" ) ) ) {

    880. 

  880. 		$theme_name = get_option( 'current_theme' );

    881. 

  881. 		if ( false === $theme_name )

    882. 

  882. 			$theme_name = wp_get_theme()->get('Name');

    883. 

  883. 		$mods = get_option( "mods_$theme_name" ); // Deprecated location.

    884. 

  884. 		if ( is_admin() && false !== $mods ) {

    885. 

  885. 			update_option( "theme_mods_$theme_slug", $mods );

    886. 

  886. 			delete_option( "mods_$theme_name" );

    887. 

  887. 		}

    888. 

  888. 	}

    889. 

  889. 	return $mods;

    890. 

  890. }

    891. 

  891. 

    892. 

  892. /**

    893. 

  893.  * Retrieve theme modification value for the current theme.

    894. 

  894.  *

    895. 

  895.  * If the modification name does not exist, then the $default will be passed

    896. 

  896.  * through {@link http://php.net/sprintf sprintf()} PHP function with the first

    897. 

  897.  * string the template directory URI and the second string the stylesheet

    898. 

  898.  * directory URI.

    899. 

  899.  *

    900. 

  900.  * @since 2.1.0

    901. 

  901.  *

    902. 

  902.  * @param string $name Theme modification name.

    903. 

  903.  * @param bool|string $default

    904. 

  904.  * @return string

    905. 

  905.  */

    906. 

  906. function get_theme_mod( $name, $default = false ) {

    907. 

  907. 	$mods = get_theme_mods();

    908. 

  908. 

    909. 

  909. 	if ( isset( $mods[$name] ) ) {

    910. 

  910. 		/**

    911. 

  911. 		 * Filter the theme modification, or 'theme_mod', value.

    912. 

  912. 		 *

    913. 

  913. 		 * The dynamic portion of the hook name, $name, refers to

    914. 

  914. 		 * the key name of the modification array. For example,

    915. 

  915. 		 * 'header_textcolor', 'header_image', and so on depending

    916. 

  916. 		 * on the theme options.

    917. 

  917. 		 *

    918. 

  918. 		 * @since 2.2.0

    919. 

  919. 		 *

    920. 

  920. 		 * @param string $current_mod The value of the current theme modification.

    921. 

  921. 		 */

    922. 

  922. 		return apply_filters( "theme_mod_{$name}", $mods[$name] );

    923. 

  923. 	}

    924. 

  924. 

    925. 

  925. 	if ( is_string( $default ) )

    926. 

  926. 		$default = sprintf( $default, get_template_directory_uri(), get_stylesheet_directory_uri() );

    927. 

  927. 

    928. 

  928. 	/** This filter is documented in wp-includes/theme.php */

    929. 

  929. 	return apply_filters( "theme_mod_{$name}", $default );

    930. 

  930. }

    931. 

  931. 

    932. 

  932. /**

    933. 

  933.  * Update theme modification value for the current theme.

    934. 

  934.  *

    935. 

  935.  * @since 2.1.0

    936. 

  936.  *

    937. 

  937.  * @param string $name Theme modification name.

    938. 

  938.  * @param string $value theme modification value.

    939. 

  939.  */

    940. 

  940. function set_theme_mod( $name, $value ) {

    941. 

  941. 	$mods = get_theme_mods();

    942. 

  942. 	$old_value = isset( $mods[ $name ] ) ? $mods[ $name ] : false;

    943. 

  943. 

    944. 

  944. 	/**

    945. 

  945. 	 * Filter the theme mod value on save.

    946. 

  946. 	 *

    947. 

  947. 	 * The dynamic portion of the hook name, $name, refers to the key name of

    948. 

  948. 	 * the modification array. For example, 'header_textcolor', 'header_image',

    949. 

  949. 	 * and so on depending on the theme options.

    950. 

  950. 	 *

    951. 

  951. 	 * @since 3.9.0

    952. 

  952. 	 *

    953. 

  953. 	 * @param string $value     The new value of the theme mod.

    954. 

  954. 	 * @param string $old_value The current value of the theme mod.

    955. 

  955. 	 */

    956. 

  956. 	$mods[ $name ] = apply_filters( "pre_set_theme_mod_$name", $value, $old_value );

    957. 

  957. 

    958. 

  958. 	$theme = get_option( 'stylesheet' );

    959. 

  959. 	update_option( "theme_mods_$theme", $mods );

    960. 

  960. }

    961. 

  961. 

    962. 

  962. /**

    963. 

  963.  * Remove theme modification name from current theme list.

    964. 

  964.  *

    965. 

  965.  * If removing the name also removes all elements, then the entire option will

    966. 

  966.  * be removed.

    967. 

  967.  *

    968. 

  968.  * @since 2.1.0

    969. 

  969.  *

    970. 

  970.  * @param string $name Theme modification name.

    971. 

  971.  * @return null

    972. 

  972.  */

    973. 

  973. function remove_theme_mod( $name ) {

    974. 

  974. 	$mods = get_theme_mods();

    975. 

  975. 

    976. 

  976. 	if ( ! isset( $mods[ $name ] ) )

    977. 

  977. 		return;

    978. 

  978. 

    979. 

  979. 	unset( $mods[ $name ] );

    980. 

  980. 

    981. 

  981. 	if ( empty( $mods ) )

    982. 

  982. 		return remove_theme_mods();

    983. 

  983. 

    984. 

  984. 	$theme = get_option( 'stylesheet' );

    985. 

  985. 	update_option( "theme_mods_$theme", $mods );

    986. 

  986. }

    987. 

  987. 

    988. 

  988. /**

    989. 

  989.  * Remove theme modifications option for current theme.

    990. 

  990.  *

    991. 

  991.  * @since 2.1.0

    992. 

  992.  */

    993. 

  993. function remove_theme_mods() {

    994. 

  994. 	delete_option( 'theme_mods_' . get_option( 'stylesheet' ) );

    995. 

  995. 

    996. 

  996. 	// Old style.

    997. 

  997. 	$theme_name = get_option( 'current_theme' );

    998. 

  998. 	if ( false === $theme_name )

    999. 

  999. 		$theme_name = wp_get_theme()->get('Name');

    1000. 

  1000. 	delete_option( 'mods_' . $theme_name );

    1001. 

  1001. }

    1002. 

  1002. 

    1003. 

  1003. /**

    1004. 

  1004.  * Retrieve text color for custom header.

    1005. 

  1005.  *

    1006. 

  1006.  * @since 2.1.0

    1007. 

  1007.  *

    1008. 

  1008.  * @return string

    1009. 

  1009.  */

    1010. 

  1010. function get_header_textcolor() {

    1011. 

  1011. 	return get_theme_mod('header_textcolor', get_theme_support( 'custom-header', 'default-text-color' ) );

    1012. 

  1012. }

    1013. 

  1013. 

    1014. 

  1014. /**

    1015. 

  1015.  * Display text color for custom header.

    1016. 

  1016.  *

    1017. 

  1017.  * @since 2.1.0

    1018. 

  1018.  */

    1019. 

  1019. function header_textcolor() {

    1020. 

  1020. 	echo get_header_textcolor();

    1021. 

  1021. }

    1022. 

  1022. 

    1023. 

  1023. /**

    1024. 

  1024.  * Whether to display the header text.

    1025. 

  1025.  *

    1026. 

  1026.  * @since 3.4.0

    1027. 

  1027.  *

    1028. 

  1028.  * @return bool

    1029. 

  1029.  */

    1030. 

  1030. function display_header_text() {

    1031. 

  1031. 	if ( ! current_theme_supports( 'custom-header', 'header-text' ) )

    1032. 

  1032. 		return false;

    1033. 

  1033. 

    1034. 

  1034. 	$text_color = get_theme_mod( 'header_textcolor', get_theme_support( 'custom-header', 'default-text-color' ) );

    1035. 

  1035. 	return 'blank' != $text_color;

    1036. 

  1036. }

    1037. 

  1037. 

    1038. 

  1038. /**

    1039. 

  1039.  * Retrieve header image for custom header.

    1040. 

  1040.  *

    1041. 

  1041.  * @since 2.1.0

    1042. 

  1042.  *

    1043. 

  1043.  * @return string

    1044. 

  1044.  */

    1045. 

  1045. function get_header_image() {

    1046. 

  1046. 	$url = get_theme_mod( 'header_image', get_theme_support( 'custom-header', 'default-image' ) );

    1047. 

  1047. 

    1048. 

  1048. 	if ( 'remove-header' == $url )

    1049. 

  1049. 		return false;

    1050. 

  1050. 

    1051. 

  1051. 	if ( is_random_header_image() )

    1052. 

  1052. 		$url = get_random_header_image();

    1053. 

  1053. 

    1054. 

  1054. 	return esc_url_raw( set_url_scheme( $url ) );

    1055. 

  1055. }

    1056. 

  1056. 

    1057. 

  1057. /**

    1058. 

  1058.  * Get random header image data from registered images in theme.

    1059. 

  1059.  *

    1060. 

  1060.  * @since 3.4.0

    1061. 

  1061.  *

    1062. 

  1062.  * @access private

    1063. 

  1063.  *

    1064. 

  1064.  * @return string Path to header image

    1065. 

  1065.  */

    1066. 

  1066. 

    1067. 

  1067. function _get_random_header_data() {

    1068. 

  1068. 	static $_wp_random_header;

    1069. 

  1069. 

    1070. 

  1070. 	if ( empty( $_wp_random_header ) ) {

    1071. 

  1071. 		global $_wp_default_headers;

    1072. 

  1072. 		$header_image_mod = get_theme_mod( 'header_image', '' );

    1073. 

  1073. 		$headers = array();

    1074. 

  1074. 

    1075. 

  1075. 		if ( 'random-uploaded-image' == $header_image_mod )

    1076. 

  1076. 			$headers = get_uploaded_header_images();

    1077. 

  1077. 		elseif ( ! empty( $_wp_default_headers ) ) {

    1078. 

  1078. 			if ( 'random-default-image' == $header_image_mod ) {

    1079. 

  1079. 				$headers = $_wp_default_headers;

    1080. 

  1080. 			} else {

    1081. 

  1081. 				if ( current_theme_supports( 'custom-header', 'random-default' ) )

    1082. 

  1082. 					$headers = $_wp_default_headers;

    1083. 

  1083. 			}

    1084. 

  1084. 		}

    1085. 

  1085. 

    1086. 

  1086. 		if ( empty( $headers ) )

    1087. 

  1087. 			return new stdClass;

    1088. 

  1088. 

    1089. 

  1089. 		$_wp_random_header = (object) $headers[ array_rand( $headers ) ];

    1090. 

  1090. 

    1091. 

  1091. 		$_wp_random_header->url =  sprintf( $_wp_random_header->url, get_template_directory_uri(), get_stylesheet_directory_uri() );

    1092. 

  1092. 		$_wp_random_header->thumbnail_url =  sprintf( $_wp_random_header->thumbnail_url, get_template_directory_uri(), get_stylesheet_directory_uri() );

    1093. 

  1093. 	}

    1094. 

  1094. 	return $_wp_random_header;

    1095. 

  1095. }

    1096. 

  1096. 

    1097. 

  1097. /**

    1098. 

  1098.  * Get random header image url from registered images in theme.

    1099. 

  1099.  *

    1100. 

  1100.  * @since 3.2.0

    1101. 

  1101.  *

    1102. 

  1102.  * @return string Path to header image

    1103. 

  1103.  */

    1104. 

  1104. 

    1105. 

  1105. function get_random_header_image() {

    1106. 

  1106. 	$random_image = _get_random_header_data();

    1107. 

  1107. 	if ( empty( $random_image->url ) )

    1108. 

  1108. 		return '';

    1109. 

  1109. 	return $random_image->url;

    1110. 

  1110. }

    1111. 

  1111. 

    1112. 

  1112. /**

    1113. 

  1113.  * Check if random header image is in use.

    1114. 

  1114.  *

    1115. 

  1115.  * Always true if user expressly chooses the option in Appearance > Header.

    1116. 

  1116.  * Also true if theme has multiple header images registered, no specific header image

    1117. 

  1117.  * is chosen, and theme turns on random headers with add_theme_support().

    1118. 

  1118.  *

    1119. 

  1119.  * @since 3.2.0

    1120. 

  1120.  *

    1121. 

  1121.  * @param string $type The random pool to use. any|default|uploaded

    1122. 

  1122.  * @return boolean

    1123. 

  1123.  */

    1124. 

  1124. function is_random_header_image( $type = 'any' ) {

    1125. 

  1125. 	$header_image_mod = get_theme_mod( 'header_image', get_theme_support( 'custom-header', 'default-image' ) );

    1126. 

  1126. 

    1127. 

  1127. 	if ( 'any' == $type ) {

    1128. 

  1128. 		if ( 'random-default-image' == $header_image_mod || 'random-uploaded-image' == $header_image_mod || ( '' != get_random_header_image() && empty( $header_image_mod ) ) )

    1129. 

  1129. 			return true;

    1130. 

  1130. 	} else {

    1131. 

  1131. 		if ( "random-$type-image" == $header_image_mod )

    1132. 

  1132. 			return true;

    1133. 

  1133. 		elseif ( 'default' == $type && empty( $header_image_mod ) && '' != get_random_header_image() )

    1134. 

  1134. 			return true;

    1135. 

  1135. 	}

    1136. 

  1136. 

    1137. 

  1137. 	return false;

    1138. 

  1138. }

    1139. 

  1139. 

    1140. 

  1140. /**

    1141. 

  1141.  * Display header image URL.

    1142. 

  1142.  *

    1143. 

  1143.  * @since 2.1.0

    1144. 

  1144.  */

    1145. 

  1145. function header_image() {

    1146. 

  1146. 	echo esc_url( get_header_image() );

    1147. 

  1147. }

    1148. 

  1148. 

    1149. 

  1149. /**

    1150. 

  1150.  * Get the header images uploaded for the current theme.

    1151. 

  1151.  *

    1152. 

  1152.  * @since 3.2.0

    1153. 

  1153.  *

    1154. 

  1154.  * @return array

    1155. 

  1155.  */

    1156. 

  1156. function get_uploaded_header_images() {

    1157. 

  1157. 	$header_images = array();

    1158. 

  1158. 

    1159. 

  1159. 	// @todo caching

    1160. 

  1160. 	$headers = get_posts( array( 'post_type' => 'attachment', 'meta_key' => '_wp_attachment_is_custom_header', 'meta_value' => get_option('stylesheet'), 'orderby' => 'none', 'nopaging' => true ) );

    1161. 

  1161. 

    1162. 

  1162. 	if ( empty( $headers ) )

    1163. 

  1163. 		return array();

    1164. 

  1164. 

    1165. 

  1165. 	foreach ( (array) $headers as $header ) {

    1166. 

  1166. 		$url = esc_url_raw( wp_get_attachment_url( $header->ID ) );

    1167. 

  1167. 		$header_data = wp_get_attachment_metadata( $header->ID );

    1168. 

  1168. 		$header_index = basename($url);

    1169. 

  1169. 		$header_images[$header_index] = array();

    1170. 

  1170. 		$header_images[$header_index]['attachment_id'] =  $header->ID;

    1171. 

  1171. 		$header_images[$header_index]['url'] =  $url;

    1172. 

  1172. 		$header_images[$header_index]['thumbnail_url'] =  $url;

    1173. 

  1173. 		if ( isset( $header_data['width'] ) )

    1174. 

  1174. 			$header_images[$header_index]['width'] = $header_data['width'];

    1175. 

  1175. 		if ( isset( $header_data['height'] ) )

    1176. 

  1176. 			$header_images[$header_index]['height'] = $header_data['height'];

    1177. 

  1177. 	}

    1178. 

  1178. 

    1179. 

  1179. 	return $header_images;

    1180. 

  1180. }

    1181. 

  1181. 

    1182. 

  1182. /**

    1183. 

  1183.  * Get the header image data.

    1184. 

  1184.  *

    1185. 

  1185.  * @since 3.4.0

    1186. 

  1186.  *

    1187. 

  1187.  * @return object

    1188. 

  1188.  */

    1189. 

  1189. function get_custom_header() {

    1190. 

  1190. 	global $_wp_default_headers;

    1191. 

  1191. 

    1192. 

  1192. 	if ( is_random_header_image() ) {

    1193. 

  1193. 		$data = _get_random_header_data();

    1194. 

  1194. 	} else {

    1195. 

  1195. 		$data = get_theme_mod( 'header_image_data' );

    1196. 

  1196. 		if ( ! $data && current_theme_supports( 'custom-header', 'default-image' ) ) {

    1197. 

  1197. 			$directory_args = array( get_template_directory_uri(), get_stylesheet_directory_uri() );

    1198. 

  1198. 			$data = array();

    1199. 

  1199. 			$data['url'] = $data['thumbnail_url'] = vsprintf( get_theme_support( 'custom-header', 'default-image' ), $directory_args );

    1200. 

  1200. 			if ( ! empty( $_wp_default_headers ) ) {

    1201. 

  1201. 				foreach ( (array) $_wp_default_headers as $default_header ) {

    1202. 

  1202. 					$url = vsprintf( $default_header['url'], $directory_args );

    1203. 

  1203. 					if ( $data['url'] == $url ) {

    1204. 

  1204. 						$data = $default_header;

    1205. 

  1205. 						$data['url'] = $url;

    1206. 

  1206. 						$data['thumbnail_url'] = vsprintf( $data['thumbnail_url'], $directory_args );

    1207. 

  1207. 						break;

    1208. 

  1208. 					}

    1209. 

  1209. 				}

    1210. 

  1210. 			}

    1211. 

  1211. 		}

    1212. 

  1212. 	}

    1213. 

  1213. 

    1214. 

  1214. 	$default = array(

    1215. 

  1215. 		'url'           => '',

    1216. 

  1216. 		'thumbnail_url' => '',

    1217. 

  1217. 		'width'         => get_theme_support( 'custom-header', 'width' ),

    1218. 

  1218. 		'height'        => get_theme_support( 'custom-header', 'height' ),

    1219. 

  1219. 	);

    1220. 

  1220. 	return (object) wp_parse_args( $data, $default );

    1221. 

  1221. }

    1222. 

  1222. 

    1223. 

  1223. /**

    1224. 

  1224.  * Register a selection of default headers to be displayed by the custom header admin UI.

    1225. 

  1225.  *

    1226. 

  1226.  * @since 3.0.0

    1227. 

  1227.  *

    1228. 

  1228.  * @param array $headers Array of headers keyed by a string id. The ids point to arrays containing 'url', 'thumbnail_url', and 'description' keys.

    1229. 

  1229.  */

    1230. 

  1230. function register_default_headers( $headers ) {

    1231. 

  1231. 	global $_wp_default_headers;

    1232. 

  1232. 

    1233. 

  1233. 	$_wp_default_headers = array_merge( (array) $_wp_default_headers, (array) $headers );

    1234. 

  1234. }

    1235. 

  1235. 

    1236. 

  1236. /**

    1237. 

  1237.  * Unregister default headers.

    1238. 

  1238.  *

    1239. 

  1239.  * This function must be called after register_default_headers() has already added the

    1240. 

  1240.  * header you want to remove.

    1241. 

  1241.  *

    1242. 

  1242.  * @see register_default_headers()

    1243. 

  1243.  * @since 3.0.0

    1244. 

  1244.  *

    1245. 

  1245.  * @param string|array $header The header string id (key of array) to remove, or an array thereof.

    1246. 

  1246.  * @return bool|void A single header returns true on success, false on failure.

    1247. 

  1247.  *                   There is currently no return value for multiple headers.

    1248. 

  1248.  */

    1249. 

  1249. function unregister_default_headers( $header ) {

    1250. 

  1250. 	global $_wp_default_headers;

    1251. 

  1251. 	if ( is_array( $header ) ) {

    1252. 

  1252. 		array_map( 'unregister_default_headers', $header );

    1253. 

  1253. 	} elseif ( isset( $_wp_default_headers[ $header ] ) ) {

    1254. 

  1254. 		unset( $_wp_default_headers[ $header ] );

    1255. 

  1255. 		return true;

    1256. 

  1256. 	} else {

    1257. 

  1257. 		return false;

    1258. 

  1258. 	}

    1259. 

  1259. }

    1260. 

  1260. 

    1261. 

  1261. /**

    1262. 

  1262.  * Retrieve background image for custom background.

    1263. 

  1263.  *

    1264. 

  1264.  * @since 3.0.0

    1265. 

  1265.  *

    1266. 

  1266.  * @return string

    1267. 

  1267.  */

    1268. 

  1268. function get_background_image() {

    1269. 

  1269. 	return get_theme_mod('background_image', get_theme_support( 'custom-background', 'default-image' ) );

    1270. 

  1270. }

    1271. 

  1271. 

    1272. 

  1272. /**

    1273. 

  1273.  * Display background image path.

    1274. 

  1274.  *

    1275. 

  1275.  * @since 3.0.0

    1276. 

  1276.  */

    1277. 

  1277. function background_image() {

    1278. 

  1278. 	echo get_background_image();

    1279. 

  1279. }

    1280. 

  1280. 

    1281. 

  1281. /**

    1282. 

  1282.  * Retrieve value for custom background color.

    1283. 

  1283.  *

    1284. 

  1284.  * @since 3.0.0

    1285. 

  1285.  *

    1286. 

  1286.  * @return string

    1287. 

  1287.  */

    1288. 

  1288. function get_background_color() {

    1289. 

  1289. 	return get_theme_mod('background_color', get_theme_support( 'custom-background', 'default-color' ) );

    1290. 

  1290. }

    1291. 

  1291. 

    1292. 

  1292. /**

    1293. 

  1293.  * Display background color value.

    1294. 

  1294.  *

    1295. 

  1295.  * @since 3.0.0

    1296. 

  1296.  */

    1297. 

  1297. function background_color() {

    1298. 

  1298. 	echo get_background_color();

    1299. 

  1299. }

    1300. 

  1300. 

    1301. 

  1301. /**

    1302. 

  1302.  * Default custom background callback.

    1303. 

  1303.  *

    1304. 

  1304.  * @since 3.0.0

    1305. 

  1305.  * @access protected

    1306. 

  1306.  */

    1307. 

  1307. function _custom_background_cb() {

    1308. 

  1308. 	// $background is the saved custom image, or the default image.

    1309. 

  1309. 	$background = set_url_scheme( get_background_image() );

    1310. 

  1310. 

    1311. 

  1311. 	// $color is the saved custom color.

    1312. 

  1312. 	// A default has to be specified in style.css. It will not be printed here.

    1313. 

  1313. 	$color = get_background_color();

    1314. 

  1314. 

    1315. 

  1315. 	if ( $color === get_theme_support( 'custom-background', 'default-color' ) ) {

    1316. 

  1316. 		$color = false;

    1317. 

  1317. 	}

    1318. 

  1318. 

    1319. 

  1319. 	if ( ! $background && ! $color )

    1320. 

  1320. 		return;

    1321. 

  1321. 

    1322. 

  1322. 	$style = $color ? "background-color: #$color;" : '';

    1323. 

  1323. 

    1324. 

  1324. 	if ( $background ) {

    1325. 

  1325. 		$image = " background-image: url('$background');";

    1326. 

  1326. 

    1327. 

  1327. 		$repeat = get_theme_mod( 'background_repeat', get_theme_support( 'custom-background', 'default-repeat' ) );

    1328. 

  1328. 		if ( ! in_array( $repeat, array( 'no-repeat', 'repeat-x', 'repeat-y', 'repeat' ) ) )

    1329. 

  1329. 			$repeat = 'repeat';

    1330. 

  1330. 		$repeat = " background-repeat: $repeat;";

    1331. 

  1331. 

    1332. 

  1332. 		$position = get_theme_mod( 'background_position_x', get_theme_support( 'custom-background', 'default-position-x' ) );

    1333. 

  1333. 		if ( ! in_array( $position, array( 'center', 'right', 'left' ) ) )

    1334. 

  1334. 			$position = 'left';

    1335. 

  1335. 		$position = " background-position: top $position;";

    1336. 

  1336. 

    1337. 

  1337. 		$attachment = get_theme_mod( 'background_attachment', get_theme_support( 'custom-background', 'default-attachment' ) );

    1338. 

  1338. 		if ( ! in_array( $attachment, array( 'fixed', 'scroll' ) ) )

    1339. 

  1339. 			$attachment = 'scroll';

    1340. 

  1340. 		$attachment = " background-attachment: $attachment;";

    1341. 

  1341. 

    1342. 

  1342. 		$style .= $image . $repeat . $position . $attachment;

    1343. 

  1343. 	}

    1344. 

  1344. ?>

    1345. 

  1345. <style type="text/css" id="custom-background-css">

    1346. 

  1346. body.custom-background { <?php echo trim( $style ); ?> }

    1347. 

  1347. </style>

    1348. 

  1348. <?php

    1349. 

  1349. }

    1350. 

  1350. 

    1351. 

  1351. /**

    1352. 

  1352.  * Add callback for custom TinyMCE editor stylesheets.

    1353. 

  1353.  *

    1354. 

  1354.  * The parameter $stylesheet is the name of the stylesheet, relative to

    1355. 

  1355.  * the theme root. It also accepts an array of stylesheets.

    1356. 

  1356.  * It is optional and defaults to 'editor-style.css'.

    1357. 

  1357.  *

    1358. 

  1358.  * This function automatically adds another stylesheet with -rtl prefix, e.g. editor-style-rtl.css.

    1359. 

  1359.  * If that file doesn't exist, it is removed before adding the stylesheet(s) to TinyMCE.

    1360. 

  1360.  * If an array of stylesheets is passed to add_editor_style(),

    1361. 

  1361.  * RTL is only added for the first stylesheet.

    1362. 

  1362.  *

    1363. 

  1363.  * Since version 3.4 the TinyMCE body has .rtl CSS class.

    1364. 

  1364.  * It is a better option to use that class and add any RTL styles to the main stylesheet.

    1365. 

  1365.  *

    1366. 

  1366.  * @since 3.0.0

    1367. 

  1367.  *

    1368. 

  1368.  * @param mixed $stylesheet Optional. Stylesheet name or array thereof, relative to theme root.

    1369. 

  1369.  * 	Defaults to 'editor-style.css'

    1370. 

  1370.  */

    1371. 

  1371. function add_editor_style( $stylesheet = 'editor-style.css' ) {

    1372. 

  1372. 

    1373. 

  1373. 	add_theme_support( 'editor-style' );

    1374. 

  1374. 

    1375. 

  1375. 	if ( ! is_admin() )

    1376. 

  1376. 		return;

    1377. 

  1377. 

    1378. 

  1378. 	global $editor_styles;

    1379. 

  1379. 	$editor_styles = (array) $editor_styles;

    1380. 

  1380. 	$stylesheet    = (array) $stylesheet;

    1381. 

  1381. 	if ( is_rtl() ) {

    1382. 

  1382. 		$rtl_stylesheet = str_replace('.css', '-rtl.css', $stylesheet[0]);

    1383. 

  1383. 		$stylesheet[] = $rtl_stylesheet;

    1384. 

  1384. 	}

    1385. 

  1385. 

    1386. 

  1386. 	$editor_styles = array_merge( $editor_styles, $stylesheet );

    1387. 

  1387. }

    1388. 

  1388. 

    1389. 

  1389. /**

    1390. 

  1390.  * Removes all visual editor stylesheets.

    1391. 

  1391.  *

    1392. 

  1392.  * @since 3.1.0

    1393. 

  1393.  *

    1394. 

  1394.  * @return bool True on success, false if there were no stylesheets to remove.

    1395. 

  1395.  */

    1396. 

  1396. function remove_editor_styles() {

    1397. 

  1397. 	if ( ! current_theme_supports( 'editor-style' ) )

    1398. 

  1398. 		return false;

    1399. 

  1399. 	_remove_theme_support( 'editor-style' );

    1400. 

  1400. 	if ( is_admin() )

    1401. 

  1401. 		$GLOBALS['editor_styles'] = array();

    1402. 

  1402. 	return true;

    1403. 

  1403. }

    1404. 

  1404. 

    1405. 

  1405. /**

    1406. 

  1406.  * Retrieve any registered editor stylesheets

    1407. 

  1407.  *

    1408. 

  1408.  * @since 4.0.0

    1409. 

  1409.  *

    1410. 

  1410.  * @global $editor_styles Registered editor stylesheets

    1411. 

  1411.  *

    1412. 

  1412.  * @return array If registered, a list of editor stylesheet URLs.

    1413. 

  1413.  */

    1414. 

  1414. function get_editor_stylesheets() {

    1415. 

  1415. 	$stylesheets = array();

    1416. 

  1416. 	// load editor_style.css if the current theme supports it

    1417. 

  1417. 	if ( ! empty( $GLOBALS['editor_styles'] ) && is_array( $GLOBALS['editor_styles'] ) ) {

    1418. 

  1418. 		$editor_styles = $GLOBALS['editor_styles'];

    1419. 

  1419. 

    1420. 

  1420. 		$editor_styles = array_unique( array_filter( $editor_styles ) );

    1421. 

  1421. 		$style_uri = get_stylesheet_directory_uri();

    1422. 

  1422. 		$style_dir = get_stylesheet_directory();

    1423. 

  1423. 

    1424. 

  1424. 		// Support externally referenced styles (like, say, fonts).

    1425. 

  1425. 		foreach ( $editor_styles as $key => $file ) {

    1426. 

  1426. 			if ( preg_match( '~^(https?:)?//~', $file ) ) {

    1427. 

  1427. 				$stylesheets[] = esc_url_raw( $file );

    1428. 

  1428. 				unset( $editor_styles[ $key ] );

    1429. 

  1429. 			}

    1430. 

  1430. 		}

    1431. 

  1431. 

    1432. 

  1432. 		// Look in a parent theme first, that way child theme CSS overrides.

    1433. 

  1433. 		if ( is_child_theme() ) {

    1434. 

  1434. 			$template_uri = get_template_directory_uri();

    1435. 

  1435. 			$template_dir = get_template_directory();

    1436. 

  1436. 

    1437. 

  1437. 			foreach ( $editor_styles as $key => $file ) {

    1438. 

  1438. 				if ( $file && file_exists( "$template_dir/$file" ) ) {

    1439. 

  1439. 					$stylesheets[] = "$template_uri/$file";

    1440. 

  1440. 				}

    1441. 

  1441. 			}

    1442. 

  1442. 		}

    1443. 

  1443. 

    1444. 

  1444. 		foreach ( $editor_styles as $file ) {

    1445. 

  1445. 			if ( $file && file_exists( "$style_dir/$file" ) ) {

    1446. 

  1446. 				$stylesheets[] = "$style_uri/$file";

    1447. 

  1447. 			}

    1448. 

  1448. 		}

    1449. 

  1449. 	}

    1450. 

  1450. 	return $stylesheets;

    1451. 

  1451. }

    1452. 

  1452. 

    1453. 

  1453. /**

    1454. 

  1454.  * Allows a theme to register its support of a certain feature

    1455. 

  1455.  *

    1456. 

  1456.  * Must be called in the theme's functions.php file to work.

    1457. 

  1457.  * If attached to a hook, it must be after_setup_theme.

    1458. 

  1458.  * The init hook may be too late for some features.

    1459. 

  1459.  *

    1460. 

  1460.  * @since 2.9.0

    1461. 

  1461.  *

    1462. 

  1462.  * @param string $feature The feature being added.

    1463. 

  1463.  * @return void|bool False on failure, void otherwise.

    1464. 

  1464.  */

    1465. 

  1465. function add_theme_support( $feature ) {

    1466. 

  1466. 	global $_wp_theme_features;

    1467. 

  1467. 

    1468. 

  1468. 	if ( func_num_args() == 1 )

    1469. 

  1469. 		$args = true;

    1470. 

  1470. 	else

    1471. 

  1471. 		$args = array_slice( func_get_args(), 1 );

    1472. 

  1472. 

    1473. 

  1473. 	switch ( $feature ) {

    1474. 

  1474. 		case 'post-formats' :

    1475. 

  1475. 			if ( is_array( $args[0] ) )

    1476. 

  1476. 				$args[0] = array_intersect( $args[0], array_keys( get_post_format_slugs() ) );

    1477. 

  1477. 			break;

    1478. 

  1478. 

    1479. 

  1479. 		case 'html5' :

    1480. 

  1480. 			// You can't just pass 'html5', you need to pass an array of types.

    1481. 

  1481. 			if ( empty( $args[0] ) ) {

    1482. 

  1482. 				// Build an array of types for back-compat.

    1483. 

  1483. 				$args = array( 0 => array( 'comment-list', 'comment-form', 'search-form' ) );

    1484. 

  1484. 			} elseif ( ! is_array( $args[0] ) ) {

    1485. 

  1485. 				_doing_it_wrong( "add_theme_support( 'html5' )", 'You need to pass an array of types.', '3.6.1' );

    1486. 

  1486. 				return false;

    1487. 

  1487. 			}

    1488. 

  1488. 

    1489. 

  1489. 			// Calling 'html5' again merges, rather than overwrites.

    1490. 

  1490. 			if ( isset( $_wp_theme_features['html5'] ) )

    1491. 

  1491. 				$args[0] = array_merge( $_wp_theme_features['html5'][0], $args[0] );

    1492. 

  1492. 			break;

    1493. 

  1493. 

    1494. 

  1494. 		case 'custom-header-uploads' :

    1495. 

  1495. 			return add_theme_support( 'custom-header', array( 'uploads' => true ) );

    1496. 

  1496. 

    1497. 

  1497. 		case 'custom-header' :

    1498. 

  1498. 			if ( ! is_array( $args ) )

    1499. 

  1499. 				$args = array( 0 => array() );

    1500. 

  1500. 

    1501. 

  1501. 			$defaults = array(

    1502. 

  1502. 				'default-image' => '',

    1503. 

  1503. 				'random-default' => false,

    1504. 

  1504. 				'width' => 0,

    1505. 

  1505. 				'height' => 0,

    1506. 

  1506. 				'flex-height' => false,

    1507. 

  1507. 				'flex-width' => false,

    1508. 

  1508. 				'default-text-color' => '',

    1509. 

  1509. 				'header-text' => true,

    1510. 

  1510. 				'uploads' => true,

    1511. 

  1511. 				'wp-head-callback' => '',

    1512. 

  1512. 				'admin-head-callback' => '',

    1513. 

  1513. 				'admin-preview-callback' => '',

    1514. 

  1514. 			);

    1515. 

  1515. 

    1516. 

  1516. 			$jit = isset( $args[0]['__jit'] );

    1517. 

  1517. 			unset( $args[0]['__jit'] );

    1518. 

  1518. 

    1519. 

  1519. 			// Merge in data from previous add_theme_support() calls.

    1520. 

  1520. 			// The first value registered wins. (A child theme is set up first.)

    1521. 

  1521. 			if ( isset( $_wp_theme_features['custom-header'] ) )

    1522. 

  1522. 				$args[0] = wp_parse_args( $_wp_theme_features['custom-header'][0], $args[0] );

    1523. 

  1523. 

    1524. 

  1524. 			// Load in the defaults at the end, as we need to insure first one wins.

    1525. 

  1525. 			// This will cause all constants to be defined, as each arg will then be set to the default.

    1526. 

  1526. 			if ( $jit )

    1527. 

  1527. 				$args[0] = wp_parse_args( $args[0], $defaults );

    1528. 

  1528. 

    1529. 

  1529. 			// If a constant was defined, use that value. Otherwise, define the constant to ensure

    1530. 

  1530. 			// the constant is always accurate (and is not defined later,  overriding our value).

    1531. 

  1531. 			// As stated above, the first value wins.

    1532. 

  1532. 			// Once we get to wp_loaded (just-in-time), define any constants we haven't already.

    1533. 

  1533. 			// Constants are lame. Don't reference them. This is just for backwards compatibility.

    1534. 

  1534. 

    1535. 

  1535. 			if ( defined( 'NO_HEADER_TEXT' ) )

    1536. 

  1536. 				$args[0]['header-text'] = ! NO_HEADER_TEXT;

    1537. 

  1537. 			elseif ( isset( $args[0]['header-text'] ) )

    1538. 

  1538. 				define( 'NO_HEADER_TEXT', empty( $args[0]['header-text'] ) );

    1539. 

  1539. 

    1540. 

  1540. 			if ( defined( 'HEADER_IMAGE_WIDTH' ) )

    1541. 

  1541. 				$args[0]['width'] = (int) HEADER_IMAGE_WIDTH;

    1542. 

  1542. 			elseif ( isset( $args[0]['width'] ) )

    1543. 

  1543. 				define( 'HEADER_IMAGE_WIDTH', (int) $args[0]['width'] );

    1544. 

  1544. 

    1545. 

  1545. 			if ( defined( 'HEADER_IMAGE_HEIGHT' ) )

    1546. 

  1546. 				$args[0]['height'] = (int) HEADER_IMAGE_HEIGHT;

    1547. 

  1547. 			elseif ( isset( $args[0]['height'] ) )

    1548. 

  1548. 				define( 'HEADER_IMAGE_HEIGHT', (int) $args[0]['height'] );

    1549. 

  1549. 

    1550. 

  1550. 			if ( defined( 'HEADER_TEXTCOLOR' ) )

    1551. 

  1551. 				$args[0]['default-text-color'] = HEADER_TEXTCOLOR;

    1552. 

  1552. 			elseif ( isset( $args[0]['default-text-color'] ) )

    1553. 

  1553. 				define( 'HEADER_TEXTCOLOR', $args[0]['default-text-color'] );

    1554. 

  1554. 

    1555. 

  1555. 			if ( defined( 'HEADER_IMAGE' ) )

    1556. 

  1556. 				$args[0]['default-image'] = HEADER_IMAGE;

    1557. 

  1557. 			elseif ( isset( $args[0]['default-image'] ) )

    1558. 

  1558. 				define( 'HEADER_IMAGE', $args[0]['default-image'] );

    1559. 

  1559. 

    1560. 

  1560. 			if ( $jit && ! empty( $args[0]['default-image'] ) )

    1561. 

  1561. 				$args[0]['random-default'] = false;

    1562. 

  1562. 

    1563. 

  1563. 			// If headers are supported, and we still don't have a defined width or height,

    1564. 

  1564. 			// we have implicit flex sizes.

    1565. 

  1565. 			if ( $jit ) {

    1566. 

  1566. 				if ( empty( $args[0]['width'] ) && empty( $args[0]['flex-width'] ) )

    1567. 

  1567. 					$args[0]['flex-width'] = true;

    1568. 

  1568. 				if ( empty( $args[0]['height'] ) && empty( $args[0]['flex-height'] ) )

    1569. 

  1569. 					$args[0]['flex-height'] = true;

    1570. 

  1570. 			}

    1571. 

  1571. 

    1572. 

  1572. 			break;

    1573. 

  1573. 

    1574. 

  1574. 		case 'custom-background' :

    1575. 

  1575. 			if ( ! is_array( $args ) )

    1576. 

  1576. 				$args = array( 0 => array() );

    1577. 

  1577. 

    1578. 

  1578. 			$defaults = …
    1579.

Large files files are truncated, but you can click here to view the full file