WordPress.org

Plugin Directory

Changeset 619235


Ignore:
Timestamp:
10/30/12 22:11:53 (18 months ago)
Author:
scribu
Message:

deploy from git

Location:
wp-useronline/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • wp-useronline/trunk/readme.txt

    r598608 r619235  
    33Tags: useronline, usersonline, wp-useronline, online, users, user, ajax, widget 
    44Requires at least: 3.1 
    5 Tested up to: 3.3 
    6 Stable tag: 2.81 
     5Tested up to: 3.5 
     6Stable tag: 2.82 
    77License: GPLv2 or later 
    88License URI: http://www.gnu.org/licenses/gpl-2.0.html 
     
    101101* show most recent visitors first 
    102102* fix duplicate entry errors 
     103* fix ajax requests for SSL 
    103104 
    104105= 2.81 = 
  • wp-useronline/trunk/scb/AdminPage.php

    r518485 r619235  
    128128        echo "<div class='wrap'>\n"; 
    129129        screen_icon( $this->args['screen_icon'] ); 
    130         echo "<h2>" . $this->args['page_title'] . "</h2>\n"; 
     130        echo html( "h2", $this->args['page_title'] ); 
    131131    } 
    132132 
     
    275275    } 
    276276 
    277     // Wraps the given content in a <table> 
    278     function table_wrap( $content ) { 
    279         return 
    280         html( 'table class="form-table"', $content ); 
    281     } 
    282  
    283     // Wraps the given content in a <tr><td> 
    284     function row_wrap( $title, $content ) { 
    285         return 
    286         html( 'tr', 
    287              html( 'th scope="row"', $title ) 
    288             .html( 'td', $content ) ); 
    289     } 
    290  
    291277    // Mimic scbForms inheritance 
    292278    function __call( $method, $args ) { 
     
    304290    // Wraps a string in a <script> tag 
    305291    function js_wrap( $string ) { 
    306         return "\n<script type='text/javascript'>\n" . $string . "\n</script>\n"; 
     292        return html( "script type='text/javascript'", $string ); 
    307293    } 
    308294 
    309295    // Wraps a string in a <style> tag 
    310296    function css_wrap( $string ) { 
    311         return "\n<style type='text/css'>\n" . $string . "\n</style>\n"; 
     297        return html( "style type='text/css'", $string ); 
    312298    } 
    313299 
  • wp-useronline/trunk/scb/Forms.php

    r598608 r619235  
    77    const TOKEN = '%input%'; 
    88 
    9     protected static $cur_name; 
    10  
    11     function input_with_value( $args, $value ) { 
    12         if ( !is_null( $value ) ) { 
    13             switch ( $args['type'] ) { 
    14             case 'select': 
    15             case 'radio': 
    16                 $args['selected'] = $value; 
    17                 break; 
    18             case 'checkbox': 
    19                 if ( is_array( $value ) ) 
    20                     $args['checked'] = $value; 
     9    static function input_with_value( $args, $value ) { 
     10        $field = scbFormField::create( $args ); 
     11 
     12        return $field->render( $value ); 
     13    } 
     14 
     15    static function input( $args, $formdata = null ) { 
     16        $field = scbFormField::create( $args ); 
     17 
     18        return $field->render( scbForms::get_value( $args['name'], $formdata ) ); 
     19    } 
     20 
     21    // Generates a table wrapped in a form 
     22    static function form_table( $rows, $formdata = null ) { 
     23        $output = ''; 
     24        foreach ( $rows as $row ) 
     25            $output .= self::table_row( $row, $formdata ); 
     26 
     27        $output = self::form_table_wrap( $output ); 
     28 
     29        return $output; 
     30    } 
     31 
     32    // Generates a form 
     33    static function form( $inputs, $formdata = null, $nonce ) { 
     34        $output = ''; 
     35        foreach ( $inputs as $input ) 
     36            $output .= self::input( $input, $formdata ); 
     37 
     38        $output = self::form_wrap( $output, $nonce ); 
     39 
     40        return $output; 
     41    } 
     42 
     43    // Generates a table 
     44    static function table( $rows, $formdata = null ) { 
     45        $output = ''; 
     46        foreach ( $rows as $row ) 
     47            $output .= self::table_row( $row, $formdata ); 
     48 
     49        $output = self::table_wrap( $output ); 
     50 
     51        return $output; 
     52    } 
     53 
     54    // Generates a table row 
     55    static function table_row( $args, $formdata = null ) { 
     56        return self::row_wrap( $args['title'], self::input( $args, $formdata ) ); 
     57    } 
     58 
     59 
     60// ____________WRAPPERS____________ 
     61 
     62 
     63    static function form_table_wrap( $content, $nonce = 'update_options' ) { 
     64        return self::form_wrap( self::table_wrap( $content ), $nonce ); 
     65    } 
     66 
     67    static function form_wrap( $content, $nonce = 'update_options' ) { 
     68        return html( "form method='post' action=''", 
     69            $content, 
     70            wp_nonce_field( $nonce, '_wpnonce', $referer = true, $echo = false ) 
     71        ); 
     72    } 
     73 
     74    static function table_wrap( $content ) { 
     75        return html( "table class='form-table'", $content ); 
     76    } 
     77 
     78    static function row_wrap( $title, $content ) { 
     79        return html( "tr", 
     80            html( "th scope='row'", $title ), 
     81            html( "td", $content ) 
     82        ); 
     83    } 
     84 
     85 
     86// ____________PRIVATE METHODS____________ 
     87 
     88 
     89// Utilities 
     90 
     91 
     92    /** 
     93     * Generates the proper string for a name attribute. 
     94     * 
     95     * @param array|string $name The raw name 
     96     * 
     97     * @return string 
     98     */ 
     99    static function get_name( $name ) { 
     100        $name = (array) $name; 
     101 
     102        $name_str = array_shift( $name ); 
     103 
     104        foreach ( $name as $key ) { 
     105            $name_str .= '[' . esc_attr( $key ) . ']'; 
     106        } 
     107 
     108        return $name_str; 
     109    } 
     110 
     111    /** 
     112     * Traverses the formdata and retrieves the correct value. 
     113     * 
     114     * @param array|string $name The name of the value 
     115     * @param array $value The data that will be traversed 
     116     * @param mixed $fallback The value returned when the key is not found 
     117     * 
     118     * @return mixed 
     119     */ 
     120    static function get_value( $name, $value, $fallback = null ) { 
     121        foreach ( (array) $name as $key ) { 
     122            if ( !isset( $value[ $key ] ) ) 
     123                return $fallback; 
     124 
     125            $value = $value[$key]; 
     126        } 
     127 
     128        return $value; 
     129    } 
     130 
     131    /** 
     132     * Given a list of fields, validate some data. 
     133     * 
     134     * @param array $fields List of args that would be sent to scbForms::input() 
     135     * @param array $data The data to validate. Defaults to $_POST 
     136     * @param array $to_update Existing data to populate. Necessary for nested values 
     137     * 
     138     * @return array 
     139     */ 
     140    static function validate_post_data( $fields, $data = null, $to_update = array() ) { 
     141        if ( null === $data ) { 
     142            $data = stripslashes_deep( $_POST ); 
     143        } 
     144 
     145        foreach ( $fields as $field ) { 
     146            $value = scbForms::get_value( $field['name'], $data ); 
     147 
     148            $fieldObj = scbFormField::create( $field ); 
     149 
     150            $value = $fieldObj->validate( $value ); 
     151 
     152            if ( null !== $value ) 
     153                self::set_value( $to_update, $field['name'], $value ); 
     154        } 
     155 
     156        return $to_update; 
     157    } 
     158 
     159    /** 
     160     * For multiple-choice fields, we can never distinguish between "never been set" and "set to none". 
     161     * For single-choice fields, we can't distinguish either, because of how self::update_meta() works. 
     162     * Therefore, the 'default' parameter is always ignored. 
     163     * 
     164     * @param array $args Field arguments. 
     165     * @param int $object_id The object ID the metadata is attached to 
     166     * @param string $meta_type 
     167     * 
     168     * @return string 
     169     */ 
     170    static function input_from_meta( $args, $object_id, $meta_type = 'post' ) { 
     171        $single = ( 'checkbox' != $args['type'] ); 
     172 
     173        $key = (array) $args['name']; 
     174        $key = end( $key ); 
     175 
     176        $value = get_metadata( $meta_type, $object_id, $key, $single ); 
     177 
     178        return self::input_with_value( $args, $value ); 
     179    } 
     180 
     181    static function update_meta( $fields, $data, $object_id, $meta_type = 'post' ) { 
     182        foreach ( $fields as $field_args ) { 
     183            $key = $field_args['name']; 
     184 
     185            if ( 'checkbox' == $field_args['type'] ) { 
     186                $new_values = isset( $data[$key] ) ? $data[$key] : array(); 
     187 
     188                $old_values = get_metadata( $meta_type, $object_id, $key ); 
     189 
     190                foreach ( array_diff( $new_values, $old_values ) as $value ) 
     191                    add_metadata( $meta_type, $object_id, $key, $value ); 
     192 
     193                foreach ( array_diff( $old_values, $new_values ) as $value ) 
     194                    delete_metadata( $meta_type, $object_id, $key, $value ); 
     195            } else { 
     196                $value = $data[$key]; 
     197 
     198                if ( '' === $value ) 
     199                    delete_metadata( $meta_type, $object_id, $key ); 
    21200                else 
    22                     $args['checked'] = ( $value || ( isset( $args['value'] ) && $value == $args['value'] ) ); 
    23                 break; 
    24             default: 
    25                 $args['value'] = $value; 
     201                    update_metadata( $meta_type, $object_id, $key, $value ); 
    26202            } 
    27203        } 
    28  
    29         return self::input( $args ); 
    30     } 
    31  
    32     static function input( $args, $formdata = false ) { 
    33         if ( false !== $formdata ) { 
    34             $form = new scbForm( $formdata ); 
    35             return $form->input( $args ); 
    36         } 
     204    } 
     205 
     206    private static function set_value( &$arr, $name, $value ) { 
     207        $name = (array) $name; 
     208 
     209        $final_key = array_pop( $name ); 
     210 
     211        while ( !empty( $name ) ) { 
     212            $key = array_shift( $name ); 
     213 
     214            if ( !isset( $arr[ $key ] ) ) 
     215                $arr[ $key ] = array(); 
     216 
     217            $arr =& $arr[ $key ]; 
     218        } 
     219 
     220        $arr[ $final_key ] = $value; 
     221    } 
     222} 
     223 
     224 
     225/** 
     226 * A wrapper for scbForms, containing the formdata 
     227 */ 
     228class scbForm { 
     229    protected $data = array(); 
     230    protected $prefix = array(); 
     231 
     232    function __construct( $data, $prefix = false ) { 
     233        if ( is_array( $data ) ) 
     234            $this->data = $data; 
     235 
     236        if ( $prefix ) 
     237            $this->prefix = (array) $prefix; 
     238    } 
     239 
     240    function traverse_to( $path ) { 
     241        $data = scbForms::get_value( $path, $this->data ); 
     242 
     243        $prefix = array_merge( $this->prefix, (array) $path ); 
     244 
     245        return new scbForm( $data, $prefix ); 
     246    } 
     247 
     248    function input( $args ) { 
     249        $value = scbForms::get_value( $args['name'], $this->data ); 
     250 
     251        if ( !empty( $this->prefix ) ) { 
     252            $args['name'] = array_merge( $this->prefix, (array) $args['name'] ); 
     253        } 
     254 
     255        return scbForms::input_with_value( $args, $value ); 
     256    } 
     257} 
     258 
     259 
     260interface scbFormField_I { 
     261 
     262    /** 
     263     * Generate the corresponding HTML for a field 
     264     * 
     265     * @param mixed $value The value to use 
     266     * 
     267     * @return string 
     268     */ 
     269    function render( $value = null ); 
     270 
     271    /** 
     272     * Validates a value against a field. 
     273     * 
     274     * @param mixed $value The value to check 
     275     * 
     276     * @return mixed null if the validation failed, sanitized value otherwise. 
     277     */ 
     278    function validate( $value ); 
     279} 
     280 
     281 
     282abstract class scbFormField implements scbFormField_I { 
     283 
     284    protected $args; 
     285 
     286    public static function create( $args ) { 
     287        if ( is_a( $args, 'scbFormField_I' ) ) 
     288            return $args; 
    37289 
    38290        if ( empty( $args['name'] ) ) { 
    39291            return trigger_error( 'Empty name', E_USER_WARNING ); 
    40292        } 
     293 
     294        if ( isset( $args['value'] ) && is_array( $args['value'] ) ) { 
     295            $args['choices'] = $args['value']; 
     296            unset( $args['value'] ); 
     297        } 
     298 
     299        if ( isset( $args['values'] ) ) { 
     300            $args['choices'] = $args['values']; 
     301            unset( $args['values'] ); 
     302        } 
     303 
     304        if ( isset( $args['extra'] ) && !is_array( $args['extra'] ) ) 
     305            $args['extra'] = shortcode_parse_atts( $args['extra'] ); 
    41306 
    42307        $args = wp_parse_args( $args, array( 
    43308            'desc' => '', 
    44309            'desc_pos' => 'after', 
    45             'wrap' => self::TOKEN, 
    46             'wrap_each' => self::TOKEN, 
     310            'wrap' => scbForms::TOKEN, 
     311            'wrap_each' => scbForms::TOKEN, 
    47312        ) ); 
    48313 
    49         if ( isset( $args['value'] ) && is_array( $args['value'] ) ) { 
    50             $args['values'] = $args['value']; 
    51             unset( $args['value'] ); 
    52         } 
    53  
    54         if ( isset( $args['extra'] ) && !is_array( $args['extra'] ) ) 
    55             $args['extra'] = shortcode_parse_atts( $args['extra'] ); 
    56  
    57         self::$cur_name = self::get_name( $args['name'] ); 
     314        // depends on $args['desc'] 
     315        if ( isset( $args['choices'] ) ) 
     316            self::_expand_choices( $args ); 
    58317 
    59318        switch ( $args['type'] ) { 
    60             case 'select': 
    61             case 'radio': 
    62                 $input = self::_single_choice( $args ); 
    63                 break; 
    64             case 'checkbox': 
    65                 if ( isset( $args['values'] ) ) 
    66                     $input = self::_multiple_choice( $args ); 
    67                 else 
    68                     $input = self::_checkbox( $args ); 
    69                 break; 
    70             default: 
    71                 $input = self::_input( $args ); 
    72         } 
    73  
    74         return str_replace( self::TOKEN, $input, $args['wrap'] ); 
    75     } 
    76  
    77  
    78 // ____________UTILITIES____________ 
    79  
    80  
    81     // Generates a table wrapped in a form 
    82     static function form_table( $rows, $formdata = NULL ) { 
    83         $output = ''; 
    84         foreach ( $rows as $row ) 
    85             $output .= self::table_row( $row, $formdata ); 
    86  
    87         $output = self::form_table_wrap( $output ); 
    88  
    89         return $output; 
    90     } 
    91  
    92     // Generates a form 
    93     static function form( $inputs, $formdata = NULL, $nonce ) { 
    94         $output = ''; 
    95         foreach ( $inputs as $input ) 
    96             $output .= self::input( $input, $formdata ); 
    97  
    98         $output = self::form_wrap( $output, $nonce ); 
    99  
    100         return $output; 
    101     } 
    102  
    103     // Generates a table 
    104     static function table( $rows, $formdata = NULL ) { 
    105         $output = ''; 
    106         foreach ( $rows as $row ) 
    107             $output .= self::table_row( $row, $formdata ); 
    108  
    109         $output = self::table_wrap( $output ); 
    110  
    111         return $output; 
    112     } 
    113  
    114     // Generates a table row 
    115     static function table_row( $args, $formdata = NULL ) { 
    116         return self::row_wrap( $args['title'], self::input( $args, $formdata ) ); 
    117     } 
    118  
    119  
    120 // ____________WRAPPERS____________ 
    121  
    122  
    123     // Wraps the given content in a <form><table> 
    124     static function form_table_wrap( $content, $nonce = 'update_options' ) { 
    125         $output = self::table_wrap( $content ); 
    126         $output = self::form_wrap( $output, $nonce ); 
    127  
    128         return $output; 
    129     } 
    130  
    131     // Wraps the given content in a <form> tag 
    132     static function form_wrap( $content, $nonce = 'update_options' ) { 
    133         $output = "\n<form method='post' action=''>\n"; 
    134         $output .= $content; 
    135         $output .= wp_nonce_field( $action = $nonce, $name = "_wpnonce", $referer = true , $echo = false ); 
    136         $output .= "\n</form>\n"; 
    137  
    138         return $output; 
    139     } 
    140  
    141     // Wraps the given content in a <table> 
    142     static function table_wrap( $content ) { 
    143         $output = "\n<table class='form-table'>\n" . $content . "\n</table>\n"; 
    144  
    145         return $output; 
    146     } 
    147  
    148     // Wraps the given content in a <tr><td> 
    149     static function row_wrap( $title, $content ) { 
    150         return "\n<tr>\n\t<th scope='row'>" . $title . "</th>\n\t<td>\n\t\t" . $content . "\t</td>\n\n</tr>"; 
    151     } 
    152  
    153  
    154 // ____________PRIVATE METHODS____________ 
    155  
    156  
    157     private static function _single_choice( $args ) { 
     319        case 'radio': 
     320            return new scbRadiosField( $args ); 
     321        case 'select': 
     322            return new scbSelectField( $args ); 
     323        case 'checkbox': 
     324            if ( isset( $args['choices'] ) ) 
     325                return new scbMultipleChoiceField( $args ); 
     326            else 
     327                return new scbSingleCheckboxField( $args ); 
     328        case 'custom': 
     329            return new scbCustomField( $args ); 
     330        default: 
     331            return new scbTextField( $args ); 
     332        } 
     333    } 
     334 
     335    protected function __construct( $args ) { 
     336        $this->args = $args; 
     337    } 
     338 
     339    public function __get( $key ) { 
     340        return $this->args[ $key ]; 
     341    } 
     342 
     343    public function __isset( $key ) { 
     344        return isset( $this->args[ $key ] ); 
     345    } 
     346 
     347    public function render( $value = null ) { 
     348        if ( null === $value && isset( $this->default ) ) 
     349            $value = $this->default; 
     350 
     351        $args = $this->args; 
     352 
     353        if ( null !== $value ) 
     354            $this->_set_value( $args, $value ); 
     355 
     356        $args['name'] = scbForms::get_name( $args['name'] ); 
     357 
     358        return str_replace( scbForms::TOKEN, $this->_render( $args ), $this->wrap ); 
     359    } 
     360 
     361    // Mutate the field arguments so that the value passed is rendered. 
     362    abstract protected function _set_value( &$args, $value ); 
     363 
     364    // The actual rendering 
     365    abstract protected function _render( $args ); 
     366 
     367    // Handle args for a single checkbox or radio input 
     368    protected static function _checkbox( $args ) { 
     369        $args = wp_parse_args( $args, array( 
     370            'value' => true, 
     371            'desc' => null, 
     372            'checked' => false, 
     373            'extra' => array(), 
     374        ) ); 
     375 
     376        foreach ( $args as $key => &$val ) 
     377            $$key = &$val; 
     378        unset( $val ); 
     379 
     380        $extra['checked'] = $checked; 
     381 
     382        if ( is_null( $desc ) && !is_bool( $value ) ) 
     383            $desc = str_replace( '[]', '', $value ); 
     384 
     385        return self::_input_gen( $args ); 
     386    } 
     387 
     388    // Generate html with the final args 
     389    protected static function _input_gen( $args ) { 
     390        extract( wp_parse_args( $args, array( 
     391            'value' => null, 
     392            'desc' => null, 
     393            'extra' => array() 
     394        ) ) ); 
     395 
     396        $extra['name'] = $name; 
     397 
     398        if ( 'textarea' == $type ) { 
     399            $input = html( 'textarea', $extra, esc_textarea( $value ) ); 
     400        } else { 
     401            $extra['value'] = $value; 
     402            $extra['type'] = $type; 
     403            $input = html( 'input', $extra ); 
     404        } 
     405 
     406        return self::add_label( $input, $desc, $desc_pos ); 
     407    } 
     408 
     409    protected static function add_label( $input, $desc, $desc_pos ) { 
     410        return html( 'label', self::add_desc( $input, $desc, $desc_pos ) ) . "\n"; 
     411    } 
     412 
     413    protected static function add_desc( $input, $desc, $desc_pos ) { 
     414        if ( empty( $desc ) ) 
     415            return $input; 
     416 
     417        if ( 'before' == $desc_pos ) 
     418            return $desc . ' ' . $input; 
     419        else 
     420            return $input . ' ' . $desc; 
     421    } 
     422 
     423    private static function _expand_choices( &$args ) { 
     424        $choices =& $args['choices']; 
     425 
     426        if ( !empty( $choices ) && !self::is_associative( $choices ) ) { 
     427            if ( is_array( $args['desc'] ) ) { 
     428                $choices = array_combine( $choices, $args['desc'] );    // back-compat 
     429                $args['desc'] = false; 
     430            } elseif ( !isset( $args['numeric'] ) || !$args['numeric'] ) { 
     431                $choices = array_combine( $choices, $choices ); 
     432            } 
     433        } 
     434    } 
     435 
     436    private static function is_associative( $array ) { 
     437        $keys = array_keys( $array ); 
     438        return array_keys( $keys ) !== $keys; 
     439    } 
     440} 
     441 
     442 
     443class scbTextField extends scbFormField { 
     444 
     445    public function validate( $value ) { 
     446        $sanitize = isset( $this->sanitize ) ? $this->sanitize : 'wp_filter_kses'; 
     447 
     448        return call_user_func( $sanitize, $value, $this ); 
     449    } 
     450 
     451    protected function _render( $args ) { 
     452        $args = wp_parse_args( $args, array( 
     453            'value' => '', 
     454            'desc_pos' => 'after', 
     455            'extra' => array( 'class' => 'regular-text' ), 
     456        ) ); 
     457 
     458        foreach ( $args as $key => &$val ) 
     459            $$key = &$val; 
     460        unset( $val ); 
     461 
     462        if ( !isset( $extra['id'] ) && !is_array( $name ) && false === strpos( $name, '[' ) ) 
     463            $extra['id'] = $name; 
     464 
     465        return scbFormField::_input_gen( $args ); 
     466    } 
     467 
     468    protected function _set_value( &$args, $value ) { 
     469        $args['value'] = $value; 
     470    } 
     471} 
     472 
     473 
     474abstract class scbSingleChoiceField extends scbFormField { 
     475 
     476    public function validate( $value ) { 
     477        if ( isset( $this->choices[ $value ] ) ) 
     478            return $value; 
     479 
     480        return null; 
     481    } 
     482 
     483    protected function _render( $args ) { 
    158484        $args = wp_parse_args( $args, array( 
    159485            'numeric' => false,     // use numeric array instead of associative 
     
    161487        ) ); 
    162488 
    163         self::_expand_values( $args ); 
    164  
    165         if ( 'select' == $args['type'] ) 
    166             return self::_select( $args ); 
    167         else 
    168             return self::_radio( $args ); 
    169     } 
    170  
    171     private static function _multiple_choice( $args ) { 
     489        return $this->_render_specific( $args ); 
     490    } 
     491 
     492    protected function _set_value( &$args, $value ) { 
     493        $args['selected'] = $value; 
     494    } 
     495 
     496    abstract protected function _render_specific( $args ); 
     497} 
     498 
     499 
     500class scbSelectField extends scbSingleChoiceField { 
     501 
     502    protected function _render_specific( $args ) { 
     503        extract( wp_parse_args( $args, array( 
     504            'text' => false, 
     505            'extra' => array() 
     506        ) ) ); 
     507 
     508        $options = array(); 
     509 
     510        if ( false !== $text ) { 
     511            $options[] = array( 
     512                'value' => '', 
     513                'selected' => ( $selected == array( 'foo' ) ), 
     514                'title' => $text 
     515            ); 
     516        } 
     517 
     518        foreach ( $choices as $value => $title ) { 
     519            $options[] = array( 
     520                'value' => $value, 
     521                'selected' => ( $value == $selected ), 
     522                'title' => $title 
     523            ); 
     524        } 
     525 
     526        $opts = ''; 
     527        foreach ( $options as $option ) { 
     528            extract( $option ); 
     529 
     530            $opts .= html( 'option', compact( 'value', 'selected' ), $title ); 
     531        } 
     532 
     533        $extra['name'] = $name; 
     534 
     535        $input = html( 'select', $extra, $opts ); 
     536 
     537        return scbFormField::add_label( $input, $desc, $desc_pos ); 
     538    } 
     539} 
     540 
     541 
     542class scbRadiosField extends scbSelectField { 
     543 
     544    protected function _render_specific( $args ) { 
     545        extract( $args ); 
     546 
     547        if ( array( 'foo' ) == $selected ) { 
     548            // radio buttons should always have one option selected 
     549            $selected = key( $choices ); 
     550        } 
     551 
     552        $opts = ''; 
     553        foreach ( $choices as $value => $title ) { 
     554            $single_input = scbFormField::_checkbox( array( 
     555                'name' => $name, 
     556                'type' => 'radio', 
     557                'value' => $value, 
     558                'checked' => ( $value == $selected ), 
     559                'desc' => $title, 
     560                'desc_pos' => 'after' 
     561            ) ); 
     562 
     563            $opts .= str_replace( scbForms::TOKEN, $single_input, $wrap_each ); 
     564        } 
     565 
     566        return scbFormField::add_desc( $opts, $desc, $desc_pos ); 
     567    } 
     568} 
     569 
     570 
     571class scbMultipleChoiceField extends scbFormField { 
     572 
     573    public function validate( $value ) { 
     574        return array_intersect( array_keys( $this->choices ), (array) $value ); 
     575    } 
     576 
     577    protected function _render( $args ) { 
    172578        $args = wp_parse_args( $args, array( 
    173579            'numeric' => false,     // use numeric array instead of associative 
     
    175581        ) ); 
    176582 
    177         self::$cur_name .= '[]'; 
    178  
    179         self::_expand_values( $args ); 
    180  
    181583        extract( $args ); 
    182584 
     
    185587 
    186588        $opts = ''; 
    187         foreach ( $values as $value => $title ) { 
    188             $single_input = self::_checkbox( array( 
     589        foreach ( $choices as $value => $title ) { 
     590            $single_input = scbFormField::_checkbox( array( 
     591                'name' => $name . '[]', 
    189592                'type' => 'checkbox', 
    190593                'value' => $value, 
     
    194597            ) ); 
    195598 
    196             $opts .= str_replace( self::TOKEN, $single_input, $args['wrap_each'] ); 
    197         } 
    198  
    199         return self::add_desc( $opts, $desc, $desc_pos ); 
    200     } 
    201  
    202     private static function _expand_values( &$args ) { 
    203         $values =& $args['values']; 
    204  
    205         if ( !empty( $values ) && !self::is_associative( $values ) ) { 
    206             if ( is_array( $args['desc'] ) ) { 
    207                 $values = array_combine( $values, $args['desc'] );  // back-compat 
    208                 $args['desc'] = false; 
    209             } elseif ( !isset( $args['numeric'] ) || !$args['numeric'] ) { 
    210                 $values = array_combine( $values, $values ); 
    211             } 
    212         } 
    213     } 
    214  
    215     private static function _radio( $args ) { 
    216         extract( $args ); 
    217  
    218         if ( array( 'foo' ) == $selected ) { 
    219             // radio buttons should always have one option selected 
    220             $selected = key( $values ); 
    221         } 
    222  
    223         $opts = ''; 
    224         foreach ( $values as $value => $title ) { 
    225             $single_input = self::_checkbox( array( 
    226                 'type' => 'radio', 
    227                 'value' => $value, 
    228                 'checked' => ( (string) $value == (string) $selected ), 
    229                 'desc' => $title, 
    230                 'desc_pos' => 'after' 
    231             ) ); 
    232  
    233             $opts .= str_replace( self::TOKEN, $single_input, $args['wrap_each'] ); 
    234         } 
    235  
    236         return self::add_desc( $opts, $desc, $desc_pos ); 
    237     } 
    238  
    239     private static function _select( $args ) { 
    240         extract( wp_parse_args( $args, array( 
    241             'text' => false, 
    242             'extra' => array() 
    243         ) ) ); 
    244  
    245         $options = array(); 
    246  
    247         if ( false !== $text ) { 
    248             $options[] = array( 
    249                 'value' => '', 
    250                 'selected' => ( $selected == array( 'foo' ) ), 
    251                 'title' => $text 
    252             ); 
    253         } 
    254  
    255         foreach ( $values as $value => $title ) { 
    256             $options[] = array( 
    257                 'value' => $value, 
    258                 'selected' => ( (string) $value == (string) $selected ), 
    259                 'title' => $title 
    260             ); 
    261         } 
    262  
    263         $opts = ''; 
    264         foreach ( $options as $option ) { 
    265             extract( $option ); 
    266  
    267             $opts .= html( 'option', compact( 'value', 'selected' ), $title ); 
    268         } 
    269  
    270         $extra['name'] = self::$cur_name; 
    271  
    272         $input = html( 'select', $extra, $opts ); 
    273  
    274         return self::add_label( $input, $desc, $desc_pos ); 
    275     } 
    276  
    277     // Handle args for a single checkbox or radio input 
    278     private static function _checkbox( $args ) { 
     599            $opts .= str_replace( scbForms::TOKEN, $single_input, $wrap_each ); 
     600        } 
     601 
     602        return scbFormField::add_desc( $opts, $desc, $desc_pos ); 
     603    } 
     604 
     605    protected function _set_value( &$args, $value ) { 
     606        $args['checked'] = (array) $value; 
     607    } 
     608} 
     609 
     610 
     611class scbSingleCheckboxField extends scbFormField { 
     612 
     613    public function validate( $value ) { 
     614        return (bool) $value; 
     615    } 
     616 
     617    protected function _render( $args ) { 
    279618        $args = wp_parse_args( $args, array( 
    280619            'value' => true, 
    281             'desc' => NULL, 
     620            'desc' => null, 
    282621            'checked' => false, 
    283622            'extra' => array(), 
     
    293632            $desc = str_replace( '[]', '', $value ); 
    294633 
    295         return self::_input_gen( $args ); 
    296     } 
    297  
    298     // Handle args for text inputs 
    299     private static function _input( $args ) { 
    300         $args = wp_parse_args( $args, array( 
    301             'value' => '', 
    302             'desc_pos' => 'after', 
    303             'extra' => array( 'class' => 'regular-text' ), 
     634        return scbFormField::_input_gen( $args ); 
     635    } 
     636 
     637    protected function _set_value( &$args, $value ) { 
     638        $args['checked'] = ( $value || ( isset( $args['value'] ) && $value == $args['value'] ) ); 
     639    } 
     640} 
     641 
     642 
     643class scbCustomField implements scbFormField_I { 
     644 
     645    protected $args; 
     646 
     647    function __construct( $args ) { 
     648        $this->args = wp_parse_args( $args, array( 
     649            'render' => 'var_dump', 
     650            'sanitize' => 'wp_filter_kses', 
    304651        ) ); 
    305  
    306         foreach ( $args as $key => &$val ) 
    307             $$key = &$val; 
    308         unset( $val ); 
    309  
    310         if ( !isset( $extra['id'] ) && !is_array( $name ) && false === strpos( $name, '[' ) ) 
    311             $extra['id'] = $name; 
    312  
    313         return self::_input_gen( $args ); 
    314     } 
    315  
    316     // Generate html with the final args 
    317     private static function _input_gen( $args ) { 
    318         extract( wp_parse_args( $args, array( 
    319             'value' => NULL, 
    320             'desc' => NULL, 
    321             'extra' => array() 
    322         ) ) ); 
    323  
    324         $extra['name'] = self::$cur_name; 
    325  
    326         if ( 'textarea' == $type ) { 
    327             $input = html( 'textarea', $extra, esc_textarea( $value ) ); 
    328         } else { 
    329             $extra['value'] = $value; 
    330             $extra['type'] = $type; 
    331             $input = html( 'input', $extra ); 
    332         } 
    333  
    334         return self::add_label( $input, $desc, $desc_pos ); 
    335     } 
    336  
    337     private static function add_label( $input, $desc, $desc_pos ) { 
    338         return html( 'label', self::add_desc( $input, $desc, $desc_pos ) ) . "\n"; 
    339     } 
    340  
    341     private static function add_desc( $input, $desc, $desc_pos ) { 
    342         if ( empty( $desc ) ) 
    343             return $input; 
    344  
    345         if ( 'before' == $desc_pos ) 
    346             return $desc . ' ' . $input; 
    347         else 
    348             return $input . ' ' . $desc; 
    349     } 
    350  
    351  
    352 // Utilities 
    353  
    354  
    355     /** 
    356      * Generates the proper string for a name attribute. 
    357      * 
    358      * @param array|string $name The raw name 
    359      * 
    360      * @return string 
    361      */ 
    362     static function get_name( $name ) { 
    363         $name = (array) $name; 
    364  
    365         $name_str = array_shift( $name ); 
    366  
    367         foreach ( $name as $key ) { 
    368             $name_str .= '[' . esc_attr( $key ) . ']'; 
    369         } 
    370  
    371         return $name_str; 
    372     } 
    373  
    374     /** 
    375      * Traverses the formdata and retrieves the correct value. 
    376      * 
    377      * @param array|string $name The name of the value 
    378      * @param array $value The data that will be traversed 
    379      * @param mixed $fallback The value returned when the key is not found 
    380      * 
    381      * @return mixed 
    382      */ 
    383     static function get_value( $name, $value, $fallback = null ) { 
    384         foreach ( (array) $name as $key ) { 
    385             if ( !isset( $value[ $key ] ) ) 
    386                 return $fallback; 
    387  
    388             $value = $value[$key]; 
    389         } 
    390  
    391         return $value; 
    392     } 
    393  
    394     /** 
    395      * Given a list of fields, extract the appropriate POST data and return it. 
    396      * 
    397      * @param array $fields List of args that would be sent to scbForms::input() 
    398      * @param array $to_update Existing data to update 
    399      * 
    400      * @return array 
    401      */ 
    402     static function validate_post_data( $fields, $to_update = array() ) { 
    403         foreach ( $fields as $field ) { 
    404             $value = scbForms::get_value( $field['name'], $_POST ); 
    405  
    406             $value = stripslashes_deep( $value ); 
    407  
    408             switch ( $field['type'] ) { 
    409             case 'checkbox': 
    410                 if ( isset( $field['values'] ) && is_array( $field['values'] ) ) 
    411                     $value = array_intersect( $field['values'], (array) $value ); 
    412                 else 
    413                     $value = (bool) $value; 
    414  
    415                 break; 
    416             case 'radio': 
    417             case 'select': 
    418                 self::_expand_values( $field ); 
    419  
    420                 if ( !isset( $field['values'][ $value ] ) ) 
    421                     continue 2; 
    422             } 
    423  
    424             self::set_value( $to_update, $field['name'], $value ); 
    425         } 
    426  
    427         return $to_update; 
    428     } 
    429  
    430     static function input_from_meta( $args, $object_id, $meta_type = 'post' ) { 
    431         $single = ( 'checkbox' != $args['type'] ); 
    432  
    433         $key = (array) $args['name']; 
    434         $key = end( $key ); 
    435  
    436         $value = get_metadata( $meta_type, $object_id, $key, $single ); 
    437  
    438         return self::input_with_value( $args, $value ); 
    439     } 
    440  
    441     static function update_meta( $fields, $data, $object_id, $meta_type = 'post' ) { 
    442         foreach ( $fields as $field_args ) { 
    443             $key = $field_args['name']; 
    444  
    445             if ( 'checkbox' == $field_args['type'] ) { 
    446                 $new_values = isset( $data[$key] ) ? $data[$key] : array(); 
    447  
    448                 $old_values = get_metadata( $meta_type, $object_id, $key ); 
    449  
    450                 foreach ( array_diff( $new_values, $old_values ) as $value ) 
    451                     add_metadata( $meta_type, $object_id, $key, $value ); 
    452  
    453                 foreach ( array_diff( $old_values, $new_values ) as $value ) 
    454                     delete_metadata( $meta_type, $object_id, $key, $value ); 
    455             } else { 
    456                 $value = $data[$key]; 
    457  
    458                 if ( '' === $value ) 
    459                     delete_metadata( $meta_type, $object_id, $key ); 
    460                 else 
    461                     update_metadata( $meta_type, $object_id, $key, $value ); 
    462             } 
    463         } 
    464     } 
    465  
    466     private static function set_value( &$arr, $name, $value ) { 
    467         $name = (array) $name; 
    468  
    469         $final_key = array_pop( $name ); 
    470  
    471         while ( !empty( $name ) ) { 
    472             $key = array_shift( $name ); 
    473  
    474             if ( !isset( $arr[ $key ] ) ) 
    475                 $arr[ $key ] = array(); 
    476  
    477             $arr =& $arr[ $key ]; 
    478         } 
    479  
    480         $arr[ $final_key ] = $value; 
    481     } 
    482  
    483     private static function is_associative( $array ) { 
    484         $keys = array_keys( $array ); 
    485         return array_keys( $keys ) !== $keys; 
    486     } 
    487 } 
    488  
    489  
    490 /** 
    491  * A wrapper for scbForms, containing the formdata 
    492  */ 
    493 class scbForm { 
    494     protected $data = array(); 
    495     protected $prefix = array(); 
    496  
    497     function __construct( $data, $prefix = false ) { 
    498         if ( is_array( $data ) ) 
    499             $this->data = $data; 
    500  
    501         if ( $prefix ) 
    502             $this->prefix = (array) $prefix; 
    503     } 
    504  
    505     function traverse_to( $path ) { 
    506         $data = scbForms::get_value( $path, $this->data ); 
    507  
    508         $prefix = array_merge( $this->prefix, (array) $path ); 
    509  
    510         return new scbForm( $data, $prefix ); 
    511     } 
    512  
    513     function input( $args ) { 
    514         $default = isset( $args['default'] ) ? $args['default'] : null; 
    515  
    516         $value = scbForms::get_value( $args['name'], $this->data, $default ); 
    517  
    518         if ( !empty( $this->prefix ) ) { 
    519             $args['name'] = array_merge( $this->prefix, (array) $args['name'] ); 
    520         } 
    521  
    522         return scbForms::input_with_value( $args, $value ); 
    523     } 
    524 } 
    525  
     652    } 
     653 
     654    public function __get( $key ) { 
     655        return $this->args[ $key ]; 
     656    } 
     657 
     658    public function __isset( $key ) { 
     659        return isset( $this->args[ $key ] ); 
     660    } 
     661 
     662    public function render( $value = null ) { 
     663        return call_user_func( $this->render, $value, $this ); 
     664    } 
     665 
     666    public function validate( $value ) { 
     667        return call_user_func( $this->sanitize, $value, $this ); 
     668    } 
     669} 
     670 
  • wp-useronline/trunk/scb/Options.php

    r518485 r619235  
    3636 
    3737    /** 
    38      * Get option values for one, many or all fields 
     38     * Get option values for one or all fields 
    3939     * 
    40      * @param string|array $field The field(s) to get 
     40     * @param string|array $field The field to get 
    4141     * @return mixed Whatever is in those fields 
    4242     */ 
    43     public function get( $field = '' ) { 
    44         $data = get_option( $this->key, array() ); 
     43    public function get( $field = null, $default = null ) { 
     44        $data = array_merge( $this->defaults, get_option( $this->key, array() ) ); 
    4545 
    46         $data = array_merge( $this->defaults, $data ); 
    47  
    48         return $this->_get( $field, $data ); 
     46        return scbForms::get_value( $field, $data, $default ); 
    4947    } 
    5048 
    5149    /** 
    52      * Get default values for one, many or all fields 
     50     * Get default values for one or all fields 
    5351     * 
    54      * @param string|array $field The field( s ) to get 
     52     * @param string|array $field The field to get 
    5553     * @return mixed Whatever is in those fields 
    5654     */ 
    57     public function get_defaults( $field = '' ) { 
    58         return $this->_get( $field, $this->defaults ); 
     55    public function get_defaults( $field = null ) { 
     56        return scbForms::get_value( $field, $this->defaults ); 
    5957    } 
    6058 
     
    9088     */ 
    9189    public function cleanup() { 
    92         $this->update( $this->_clean( $this->get() ) ); 
     90        $this->update( $this->get(), true ); 
    9391    } 
    9492 
     
    130128    } 
    131129 
    132     // Get one, more or all fields from an array 
    133130    private function &_get( $field, $data ) { 
    134         if ( empty( $field ) ) 
    135             return $data; 
    136  
    137         if ( is_string( $field ) ) 
    138             return $data[$field]; 
    139  
    140         foreach ( $field as $key ) 
    141             if ( isset( $data[$key] ) ) 
    142                 $result[] = $data[$key]; 
    143  
    144         return $result; 
    145131    } 
    146132 
  • wp-useronline/trunk/scb/Util.php

    r518485 r619235  
    120120// Return a standard admin notice 
    121121function scb_admin_notice( $msg, $class = 'updated' ) { 
    122     return "<div class='$class fade'><p>$msg</p></div>\n"; 
     122    return html( "div class='$class fade'", html( "p", $msg ) ); 
    123123} 
    124124 
     
    146146if ( ! function_exists( 'html' ) ): 
    147147function html( $tag ) { 
     148    static $SELF_CLOSING_TAGS = array( 'area', 'base', 'basefont', 'br', 'hr', 'input', 'img', 'link', 'meta' ); 
     149 
    148150    $args = func_get_args(); 
    149151 
     
    166168    } 
    167169 
    168     if ( in_array( $closing, array( 'area', 'base', 'basefont', 'br', 'hr', 'input', 'img', 'link', 'meta' ) ) ) { 
     170    if ( in_array( $closing, $SELF_CLOSING_TAGS ) ) { 
    169171        return "<{$tag} />"; 
    170172    } 
     
    186188endif; 
    187189 
     190function scb_get_query_flags( $wp_query = null ) { 
     191    if ( !$wp_query ) 
     192        $wp_query = $GLOBALS['wp_query']; 
     193 
     194    $flags = array(); 
     195    foreach ( get_object_vars( $wp_query ) as $key => $val ) { 
     196        if ( 'is_' == substr( $key, 0, 3 ) && $val ) 
     197            $flags[] = substr( $key, 3 ); 
     198    } 
     199 
     200    return $flags; 
     201} 
    188202 
    189203//_____Compatibility layer_____ 
  • wp-useronline/trunk/scb/load.php

    r598608 r619235  
    11<?php 
    22 
    3 $GLOBALS['_scb_data'] = array( 52, __FILE__, array( 
     3$GLOBALS['_scb_data'] = array( 57, __FILE__, array( 
    44    'scbUtil', 'scbOptions', 'scbForms', 'scbTable', 
    55    'scbWidget', 'scbAdminPage', 'scbBoxesPage', 
     
    3333        } 
    3434 
    35         // TODO: don't load when activating a plugin ? 
    36         add_action( 'plugins_loaded', array( __CLASS__, 'load' ), 9, 0 ); 
     35        if ( did_action( 'plugins_loaded' ) ) 
     36            self::load(); 
     37        else 
     38            add_action( 'plugins_loaded', array( __CLASS__, 'load' ), 9, 0 ); 
    3739    } 
    3840 
  • wp-useronline/trunk/wp-useronline.php

    r598608 r619235  
    44Plugin URI: http://wordpress.org/extend/plugins/wp-useronline/ 
    55Description: Enable you to display how many users are online on your Wordpress site 
    6 Version: 2.82-beta2 
     6Version: 2.82 
    77Author: Lester 'GaMerZ' Chan & scribu 
    88*/ 
Note: See TracChangeset for help on using the changeset viewer.