WordPress.org
Get WordPress

Plugin Directory

Changeset 762516


Ignore:
Timestamp:
08/26/2013 04:33:05 PM (13 years ago)
Author:
nickohrn
Message:

Fixed issue with Google Fonts not recognizing the enabled fonts, leading to not being able to disable them.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • web-fonts/trunk/modules/google-web-fonts/google-web-fonts.php

    r523474 r762516  
    1111if(!class_exists('Google_Web_Fonts_Plugin')) {
    1212    class Google_Web_Fonts_Plugin {
    13        
     13
    1414        /// KEYS
    15        
     15
    1616        //// VERSION
    1717        const VERSION = '1.0.0-RC2';
    18        
     18
    1919        //// KEYS
    2020        const SETTINGS_KEY = '_google_web_fonts_settings';
    21        
     21
    2222        const FONT_DATA_KEY = '_google_web_fonts_fonts';
    2323        const SELECTOR_DATA_KEY = '_google_web_fonts_selectors';
    2424        const SORTABLE_FONT_TRANSIENT_BASE = '_google_web_fonts_fonts_';
    2525        const SORTABLE_FONT_TRANSIENT_TIMEOUT = 600;
    26        
     26
    2727        /// DATA STORAGE
    2828        public static $admin_page_hooks = array();
    2929        private static $default_settings = array();
    3030        private static $variants_map = array();
    31        
     31
    3232        public static function init() {
    3333            self::add_actions();
    3434            self::add_filters();
    3535            self::initialize_defaults();
    36                
     36
    3737            if(function_exists('register_web_fonts_provider')) {
    3838                register_web_fonts_provider('Google_Web_Fonts_Provider');
    3939            }
    4040        }
    41        
     41
    4242        private static function add_actions() {
    4343            if(is_admin()) {
    … …  
    4949                add_action('wp_head', array(__CLASS__, 'display_styles'), 11);
    5050            }
    51            
     51
    5252            add_action('wp_ajax_web_fonts_google_web_fonts_clear_key', array(__CLASS__, 'ajax_container'));
    5353            add_action('wp_ajax_web_fonts_google_web_fonts_set_key', array(__CLASS__, 'ajax_container'));
    54            
     54
    5555            add_action('wp_ajax_web_fonts_google_web_fonts_get_fonts', array(__CLASS__, 'ajax_container'));
    5656            add_action('wp_ajax_web_fonts_google_web_fonts_set_font_status', array(__CLASS__, 'ajax_container'));
    5757        }
    58        
     58
    5959        private static function add_filters() {
    6060            add_filter('web_fonts_manage_stylesheet_fonts_and_selectors', array(__CLASS__, 'add_stylesheet_fonts_and_selectors'));
    … …  
    8484            self::$variants_map['italic'] = __('Normal');
    8585            self::$variants_map['regular'] = __('Normal');
    86            
    87         }
    88        
     86
     87        }
     88
    8989        /// AJAX CALLBACKS
    90        
     90
    9191        public static function ajax_container() {
    9292            $data = self::trim_r(stripslashes_deep($_REQUEST));
    9393            $action = str_replace('web_fonts_google_web_fonts_', '', $data['action']);
    9494            $method_name = "ajax_{$action}";
    95            
     95
    9696            if(isset($data['nonce']) && wp_verify_nonce($data['nonce'], 'google-web-fonts-action') && method_exists(__CLASS__, $method_name)) {
    9797                $results = self::$method_name($data);
    … …  
    9999                $results = self::get_response(array(), __('Something went wrong. Please refresh the page and try again.'), true);
    100100            }
    101            
     101
    102102            header('Content-Type: application/json');
    103103            echo json_encode($results);
    104104            exit;
    105105        }
    106        
     106
    107107        public static function ajax_clear_key($data) {
    108108            self::set_settings(array());
    109            
     109
    110110            return self::get_response(array(), __('The authentication key was successfully cleared.'));
    111111        }
    112        
     112
    113113        public static function ajax_set_key($data) {
    114114            $fonts = self::get_fonts($data['key'], '', 'alpha', 0, 1, true);
    115            
     115
    116116            if(is_wp_error($fonts)) {
    117117                $results = self::get_response(array(), __('Your API Key could not be validated. Please enter a valid key.'), true);
    118118            } else {
    119119                self::set_settings(array('api-key' => $data['key']));
    120                
     120
    121121                $results = self::get_response(array('key' => $data['key']), __('Your API Key has been validated and saved.'), false);
    122122            }
    123            
     123
    124124            return $results;
    125125        }
    … …  
    128128            $page = isset($data['page_number']) && is_numeric($data['page_number']) && $data['page_number'] >= 1 ? (intval($data['page_number']) - 1) : 0;
    129129            $page_limit = 12;
    130            
     130
    131131            $search_keyword = $data['search_keyword'];
    132132            $search_sort = $data['search_sort'];
    133133            $settings = self::get_settings();
    134            
     134
    135135            $font_search_response = self::get_fonts($settings['api-key'], $search_keyword, $search_sort, $page, $page_limit);
    136            
     136
    137137            if(is_wp_error($font_search_response)) {
    138138                $results = self::get_response(null, __('There was an issue retrieving the appropriate fonts. Please try again.'), true);
    … …  
    140140                $results = self::get_response($font_search_response);
    141141            }
    142            
     142
    143143            return $results;
    144144        }
    145        
     145
    146146        public static function ajax_set_font_status($data) {
    147147            $enabled = ($data['enabled'] == 1);
    148148            $font_data = $data['font_data'];
    149149            $font_key = sanitize_title_with_dashes($font_data['family_name']);
    150            
     150
    151151            $enabled_fonts = self::get_font_data();
    152            
     152
    153153            if($enabled) {
    154154                $enabled_fonts[$font_key] = $font_data;
    … …  
    156156                unset($enabled_fonts[$font_key]);
    157157            }
    158            
     158
    159159            self::set_font_data($enabled_fonts);
    160            
     160
    161161            $results = self::get_response(array('enabled' => $enabled, 'font_data' => $font_data, 'enabled_fonts' => $enabled_fonts), sprintf(__('The selected font was %s.'), ($enabled ? __('enabled') : __('disabled'))));
    162            
     162
    163163            return $results;
    164164        }
    165165
    166166        /// CALLBACKS
    167        
     167
    168168        public static function add_stylesheet_fonts_and_selectors($data) {
    169169            $enabled_fonts = self::get_font_data();
    170170            $enabled_selectors = self::get_selector_data();
    171            
     171
    172172            $font_selector_map = array();
    173            
     173
    174174            foreach($enabled_selectors as $enabled_selector_id => $enabled_selector) {
    175175                $data['selectors'][] = $prepared_selector = web_fonts_prepare_selector_item('google-web-fonts', $enabled_selector_id, $enabled_selector['tag'], $enabled_selector['fallback'], 'google-web-fonts-' . $enabled_selector['font-id']);
    176                
     176
    177177                if(!empty($enabled_selector['font-id']) && isset($enabled_fonts[$enabled_selector['font-id']])) {
    178178                    if(!is_array($font_selector_map[$enabled_selector['font-id']])) {
    … …  
    182182                }
    183183            }
    184            
     184
    185185            foreach($enabled_fonts as $enabled_font_id => $enabled_font) {
    186186                $data['fonts'][] = web_fonts_prepare_font_item('google-web-fonts', $enabled_font_id, $enabled_font['family_name'], $enabled_font['family'], 'Quick Brown Fox Jumped Over The Lazy Dog', $font_selector_map[$enabled_font_id], array('fontFamily' => $enabled_font['family'], 'fontStyle' => $enabled_font['style'], 'fontWeight' => $enabled_font['weight']));
    187187            }
    188        
     188
    189189            return $data;
    190190        }
    191        
     191
    192192        public static function detect_submissions() {
    193193            $data = stripslashes_deep($_REQUEST);
    194194        }
    195        
     195
    196196        public static function enqueue_administrative_resources($hook) {
    197197            // This is a kludy hack and I hate it, but oh well - have to do it
    … …  
    199199                self::enqueue_frontend_resources();
    200200            }
    201            
     201
    202202            if(!in_array($hook, self::$admin_page_hooks)) { return; }
    203            
     203
    204204            wp_enqueue_script('google-web-fonts-backend', plugins_url('resources/backend/google-web-fonts.js', __FILE__), array('jquery', 'jquery-form', 'thickbox'), self::VERSION);
    205205            wp_enqueue_style('google-web-fonts-backend', plugins_url('resources/backend/google-web-fonts.css', __FILE__), array('thickbox'), self::VERSION);
    206            
     206
    207207            $strings = array(
    208208                'request_in_progress_message' => __('There is already a request in progress. Please wait until the request has completed before trying another action.'),
    … …  
    210210                'enabled_fonts_title' => __('Enabled Fonts'),
    211211            );
    212            
     212
    213213            wp_localize_script('google-web-fonts-backend', 'Google_Web_Fonts_Config', $strings);
    214214        }
    215        
     215
    216216        public static function enqueue_frontend_resources() {
    217217            $enabled_fonts = self::get_font_data();
    218            
     218
    219219            if(!empty($enabled_fonts)) {
    220220                $url_parts = array();
    … …  
    228228            }
    229229        }
    230        
     230
    231231        public static function handle_stylesheet_fonts($fonts) {
    232232            $selectors_to_save = array();
    233            
     233
    234234            foreach($fonts as $font) {
    235235                if('google-web-fonts' == $font->provider && is_array($font->selectors)) {
    … …  
    243243                }
    244244            }
    245            
     245
    246246            self::set_selector_data($selectors_to_save);
    247            
     247
    248248            return $fonts;
    249249        }
    250        
     250
    251251        public static function handle_stylesheet_selectors($selectors) {
    252252            $selectors_to_save = array();
    253            
     253
    254254            foreach($selectors as $selector) {
    255255                $font = $selector->font;
    256                
     256
    257257                if(is_object($font) && 0 === strpos($font->id, 'google-web-fonts-')) {
    258258                    $selectors_to_save['google-web-fonts-' . $selector->tag] = array(
    … …  
    263263                }
    264264            }
    265            
     265
    266266            self::set_selector_data($selectors_to_save);
    267            
     267
    268268            return $selectors;
    269269        }
    270        
     270
    271271        /// DISPLAY CALLBACKS
    272        
     272
    273273        public static function display_styles() {
    274             $font_data = self::get_font_data(); 
     274            $font_data = self::get_font_data();
    275275            $selector_data = self::get_selector_data();
    276            
     276
    277277            if(!empty($selector_data)) {
    278278                echo "\n<!-- Google Web Fonts Style Declarations -->\n";
    … …  
    281281                    if(isset($font_data[$selector['font-id']])) {
    282282                        $font = $font_data[$selector['font-id']];
    283                        
     283
    284284                        printf('%s{font-family: "%s"%s; font-style: %s; font-weight: %d}', $selector['tag'], esc_attr($font['family']), empty($selector['fallback']) ? '' : ',' . esc_attr($selector['fallback']), $font['style'], $font['weight']);
    285285                    }
    … …  
    289289            }
    290290        }
    291        
     291
    292292        public static function display_settings_page() {
    293293            $data = stripslashes_deep($_REQUEST);
    294            
     294
    295295            $settings = self::get_settings();
    296296            $is_setup = self::is_setup();
    297            
     297
    298298            $base_url = add_query_arg(array('page' => $data['page']), admin_url('admin.php'));
    299299            $valid_tabs = $is_setup ? array('setup', 'fonts') : array('setup');
    300300            $current_tab = in_array($data['tab'], $valid_tabs) ? $data['tab'] : ($is_setup ? 'fonts' : 'setup');
    301            
     301
    302302            include('views/backend/settings/_inc/nav.php');
    303            
     303
    304304            // Make this dynamic
    305305            switch($current_tab) {
    … …  
    314314
    315315        /// FONTS
    316        
     316
    317317        private static function get_font_data() {
    318318            $font_data = wp_cache_get(self::FONT_DATA_KEY);
    319            
     319
    320320            if(!is_array($selector_data)) {
    321321                $font_data = get_option(self::FONT_DATA_KEY, array());
    322322                wp_cache_set(self::FONT_DATA_KEY, $font_data, null, time() + CACHE_PERIOD);
    323323            }
    324            
     324
    325325            return $font_data;
    326326        }
    327        
     327
    328328        private static function set_font_data($font_data) {
    329329            if(is_array($font_data)) {
    … …  
    332332            }
    333333        }
    334        
     334
    335335        /// SELECTORS
    336        
     336
    337337        private static function get_selector_data() {
    338338            $selector_data = wp_cache_get(self::SELECTOR_DATA_KEY);
    339            
     339
    340340            if(!is_array($selector_data)) {
    341341                $selector_data = get_option(self::SELECTOR_DATA_KEY, array());
    342342                wp_cache_set(self::SELECTOR_DATA_KEY, $selector_data, null, time() + CACHE_PERIOD);
    343343            }
    344            
     344
    345345            return $selector_data;
    346346        }
    347        
     347
    348348        private static function set_selector_data($selector_data) {
    349349            if(is_array($selector_data)) {
    … …  
    352352            }
    353353        }
    354        
     354
    355355        /// SETTINGS
    356        
     356
    357357        private static function get_settings() {
    358358            $settings = wp_cache_get(self::SETTINGS_KEY);
    359            
     359
    360360            if(!is_array($settings)) {
    361361                $settings = wp_parse_args(get_option(self::SETTINGS_KEY, self::$default_settings), self::$default_settings);
    362362                wp_cache_set(self::SETTINGS_KEY, $settings, null, time() + CACHE_PERIOD);
    363363            }
    364            
     364
    365365            return $settings;
    366366        }
    367        
     367
    368368        private static function set_settings($settings) {
    369369            if(is_array($settings)) {
    … …  
    373373            }
    374374        }
    375        
     375
    376376        /// UTILITY
    377        
     377
    378378        private static function get_response($data = array(), $message = null, $error = false) {
    379379            return array_merge(array('error' => (bool)$error, 'message' => $message), (array)$data);
    380380        }
    381        
     381
    382382        private static function is_setup() {
    383383            $settings = self::get_settings();
    384            
     384
    385385            return !empty($settings['api-key']);
    386386        }
    387        
     387
    388388        private static function trim_r($data) {
    389389            if(is_array($data)) {
    … …  
    397397            }
    398398        }
    399        
     399
    400400        /// API
    401        
     401
    402402        private static function SORTABLE_FONT_TRANSIENT_BASE($sort) {
    403403            return self::SORTABLE_FONT_TRANSIENT_BASE . $sort;
    404404        }
    405        
     405
    406406        private static function get_api($api_key = null) {
    407407            require_once('lib/wp-google-web-fonts-api.php');
    408            
     408
    409409            return new WP_Google_Web_Fonts_API($api_key);
    410410        }
    411        
     411
    412412        private static function get_fonts($api_key, $search_keyword = '', $search_sort = 'alpha', $page = 0, $page_limit = 12, $fresh = false) {
    413413            if(!self::is_valid_sort($search_sort)) {
    414414                $search_sort = 'alpha';
    415415            }
    416            
     416
    417417            $key = self::SORTABLE_FONT_TRANSIENT_BASE($search_sort);
    418            
     418
    419419            if(!$fresh) {
    420420                $fonts = get_transient($key);
    421421            }
    422            
     422
    423423            if(!is_array($fonts)) {
    424424                $api = self::get_api($api_key);
    425425                $fonts = $api->get_fonts($search_sort);
    426                
     426
    427427                if(is_array($fonts)) {
    428428                    $fonts = self::separate_fonts($fonts);
    … …  
    430430                }
    431431            }
    432            
     432
    433433            if(is_array($fonts)) {
    434                
     434
    435435                if(!empty($search_keyword)) {
    436436                    $filtered_fonts = array();
    437                    
     437
    438438                    foreach($fonts as $font) {
    439439                        if(false !== strpos($font->family_name, $search_keyword)) {
    … …  
    441441                        }
    442442                    }
    443                    
     443
    444444                    $fonts = $filtered_fonts;
    445445                }
    446                
     446
    447447                foreach($fonts as $font) {
    448448                    $font->is_enabled = self::is_font_enabled($font);
    449449                }
    450                
     450
    451451                // This has to stay here before we array_slice
    452452                $number_fonts = count($fonts);
    453                
     453
    454454                $enabled_fonts = self::get_font_data();
    455455                $fonts = array_slice($fonts, ($page * $page_limit), $page_limit);
    … …  
    469469                    'add_fragment' => ''
    470470                ));
    471                
     471
    472472                return compact('enabled_fonts', 'fonts', 'number_fonts', 'pagination_links');
    473473            } else {
    … …  
    475475            }
    476476        }
    477        
     477
    478478        private static function is_valid_sort($sort) {
    479479            return in_array($sort, array('alpha', 'date', 'popularity', 'style', 'trending'));
    480480        }
    481        
     481
    482482        private static function separate_fonts($fonts) {
    483483            $separated_fonts = array();
    484            
     484
    485485            foreach($fonts as $font) {
    486486                $variants = $font->variants;
    487487                unset($font->variants);
    488                
     488
    489489                foreach($variants as $variant) {
    490490                    $separated_fonts[] = self::add_variant_properties($font, $variant);
    491491                }
    492492            }
    493            
     493
    494494            return $separated_fonts;
    495495        }
    496        
     496
    497497        private static function add_variant_properties($font, $variant) {
    498498            if('bold' === $variant || 'bolditalic' === $variant) {
    … …  
    503503                $weight = preg_replace('/[^\d]/', '', $variant);
    504504            }
    505            
     505
    506506            $a_font = clone $font;
    507507            $a_font->family_name = sprintf('%s %s', $a_font->family, isset(self::$variants_map[$variant]) ? self::$variants_map[$variant] : __('Normal'));
    … …  
    513513            $a_font->weight = $weight;
    514514            $a_font->weight_string = self::get_weight_string($a_font->weight);
    515            
     515
    516516            return $a_font;
    517517        }
    … …  
    519519        private static function is_font_enabled($font) {
    520520            $enabled_fonts = self::get_font_data();
    521            
    522             return isset($enabled_fonts[$font->family_name]);
    523         }
    524        
     521
     522            return isset($enabled_fonts[$font->id]);
     523        }
     524
    525525        private static function get_weight_string($weight) {
    526526            return isset(self::$variants_map[$weight]) ? self::$variants_map[$weight] : __('Normal');
    527527        }
    528528    }
    529    
     529
    530530    require_once('lib/provider.php');
    531531    Google_Web_Fonts_Plugin::init();
Note: See TracChangeset for help on using the changeset viewer.