Overview

Namespaces

  • None
  • PHP

Classes

  • Sidecar
  • Sidecar_Admin_Page
  • Sidecar_Admin_Tab
  • Sidecar_Field
  • Sidecar_Form
  • Sidecar_Plugin_Base
  • Sidecar_Settings
  • Sidecar_Shortcode
  • Sidecar_Singleton_Base

Functions

  • body
  • format_gmt_string
  • headers
  • output_css
  • Overview
  • Namespace
  • Class
  • Tree
  • Deprecated
  • Todo
  • Download
  1: <?php
  2: 
  3: /**
  4:  * Class Sidecar_Settings
  5:  */
  6: class Sidecar_Settings {
  7: 
  8:   /**
  9:    * @var string
 10:    */
 11:   var $option_name;
 12: 
 13:   /**
 14:    * @var array
 15:    */
 16:   private $_settings_values = array();
 17: 
 18:   /**
 19:    * @var array
 20:    */
 21:   private $_state;
 22: 
 23:   /**
 24:    * @var bool
 25:    */
 26:   private $_is_decrypted;
 27: 
 28:   /**
 29:    * @var Sidecar_Plugin_Base|Sidecar_Settings
 30:    */
 31:   private $_parent;
 32: 
 33:   /**
 34:    * @var bool
 35:    */
 36:   protected $_is_dirty = false;
 37: 
 38:   /**
 39:    * @var array List of names for required fields.
 40:    */
 41:   private $_required_settings = array();
 42: 
 43:   /**
 44:    * @var string
 45:    */
 46:   var $installed_version;
 47: 
 48:   /**
 49:    * @var bool
 50:    */
 51:   var $configured = false;
 52: 
 53:   /**
 54:    * @param string $option_name
 55:    * @param Sidecar_Plugin_Base|Sidecar_Settings $parent
 56:    */
 57:   function __construct( $option_name, $parent ) {
 58:     $this->option_name = $option_name;
 59:     $this->_parent = $parent;
 60:     $this->load_settings();
 61:     if ( method_exists( $this->_parent, 'filter_settings' ) )
 62:       $this->_settings = $this->_parent->filter_settings( $this->_settings, $args );
 63: 
 64:     /**
 65:      * If this' parent is not Sidecar_Settings then autosave on shutdown.
 66:      */
 67:     if ( ! is_a( $this->_parent, __CLASS__ ) )
 68:       add_action( 'shutdown', array( $this, 'shutdown' ) );
 69: 
 70:   }
 71: 
 72:   /**
 73:    * Autosave dirty settings on shutdown
 74:    */
 75:   function shutdown() {
 76:     if ( $this->_is_dirty ) {
 77:       /**
 78:        * @var Sidecar_Settings|mixed $value
 79:        */
 80:       foreach( $this->_settings_values as $setting_name => $setting_value ) {
 81:         if ( is_a( $value, __CLASS__ ) && $value->is_decrypted() && method_exists( $this->_parent, 'encrypt_settings' ) ) {
 82:           $this->_settings_values[$setting_name] = call_user_func(
 83:             array( $this->_parent, 'encrypt_settings' ),
 84:             $this->_settings[$setting_name],
 85:             $this
 86:           );
 87:           $value->set_decrypted( false );
 88:         }
 89:       }
 90:       $this->save_settings();
 91:     }
 92:   }
 93: 
 94:   /**
 95:    * Get a string representing the encryption status
 96:    * @param bool|string $setting_name
 97:    * @return string
 98:    */
 99:   function is_decrypted( $setting_name = false ) {
100:     if ( $setting_name ) {
101:       $is_decrypted = $this->get_setting( $setting_name )->is_decrypted();
102:     } else if ( ! is_a( $this->_parent, __CLASS__ ) ) {
103:       $is_decrypted = $this->_is_decrypted;
104:     } else {
105:       $is_decrypted = true;
106:       /**
107:        * Can't cache this (sung to the tune of MC Hammer's U Can't Touch This...)
108:        *
109:        * @var Sidecar_Settings $value
110:        */
111:       foreach( $this->_settings_values as $name => $value ) {
112:         if ( is_a( $value, __CLASS__ ) && ! $value->is_decrypted() ) {
113:           $is_decrypted = false;
114:         }
115:       }
116:     }
117:     return $is_decrypted;
118:   }
119: 
120:   /**
121:    * @param bool $decrypted
122:    */
123:   function set_decrypted( $decrypted ) {
124:     if ( ! is_a( $this->_parent, __CLASS__ ) )
125:       $this->_is_decrypted = $decrypted;
126:   }
127: 
128:   /**
129:    * @todo Implement decryption
130:    * @param Sidecar_Settings $settings
131:    * @param Sidecar_Form $caller
132:    *
133:    * @return mixed
134:    */
135:   function decrypt_settings( $settings, $caller ) {
136:     if ( method_exists( $this->_parent, 'decrypt_settings' ) ) {
137:       $settings = call_user_func( array( $this->_parent, 'decrypt_settings' ), $settings, $caller, $this );
138:       $settings->set_decrypted( true );
139:     }
140:     return $settings;
141:   }
142: 
143:   /**
144:    * @param string $setting_name
145:    *
146:    * @return bool
147:    */
148:   function has_setting( $setting_name ) {
149:     return isset( $this->_settings_values[$setting_name] );
150:   }
151: 
152:   /**
153:    * @param string $setting_name
154:    *
155:    * @return bool|mixed|Sidecar_Settings
156:    */
157:   function get_setting( $setting_name ) {
158: 
159:     if ( ! isset( $this->_settings_values[$setting_name] ) )
160:       $this->_settings_values[$setting_name] = new Sidecar_Settings( $setting_name, $this );
161: 
162:     if ( method_exists( $this->_parent, $method_name = "get_setting_{$setting_name}" ) )
163:       call_user_func( array( $this->_parent, $method_name ), $settings );
164: 
165:     if ( ! $plugin_settings->is_decrypted( $setting_name ) )
166:       $plugin_settings->decrypt_settings( $form_settings, $this );
167: 
168:     return $this->_settings_values[$setting_name];
169:   }
170: 
171:   /**
172:    * @return array
173:    */
174:   function get_settings_values() {
175:     return $this->_settings_values;
176:   }
177: 
178:   /**
179:    * Accepts an array of name/value pairs and assigns  the settings.
180:    *
181:    * @param array $settings
182:    */
183:   function initialize_settings( $settings ) {
184:     if ( is_array( $settings ) )
185:      foreach( $settings as $name => $value ) {
186:        /*
187:         * Objects are probably forms and non-objects probably form fields.
188:         */
189:        if ( is_array( $value ) ) {
190:          $child_settings = $this->get_setting( $name, $this );
191:          $child_settings->initialize_settings( $value );
192:          $this->_settings_values[$name] = $child_settings;
193:        } else if ( empty( $this->_settings_values[$name] ) ) {
194:           $this->_settings_values[$name] = $value;
195:         }
196:       }
197:   }
198: 
199:   /**
200:    * @param array $settings_values
201:    * @param bool $set_dirty
202:    */
203:   function update_settings_values( $settings_values, $set_dirty = true ) {
204:     $this->_settings_values = is_array( $settings_values ) ? $settings_values : array();
205:     if ( $set_dirty )
206:       $this->_is_dirty = true;
207:   }
208: 
209:   /**
210:    * @param string $setting_name
211:    * @param mixed $value
212:    * @param bool $set_dirty
213:    * @return array
214:    */
215:   function update_settings_value( $setting_name, $value, $set_dirty = true ) {
216:     $this->_settings_values[$setting_name] = $value;
217:     if ( $set_dirty )
218:       $this->_is_dirty = true;
219:   }
220: 
221:   /**
222:    * Update the settings based on an array of option values
223:    *
224:    * The keys in top level/global array are probably form names and the keys in the subject arrays are field names.
225:    * This is different from "Settings Values" in that the top level array contains form objects vs. arrays of values.
226:    *
227:    * @param $settings_array
228:    */
229:   function update_settings_array( $settings_array ) {
230:     foreach( $settings_array as $name => $value ) {
231:       $settings = $this->get_setting( $name );
232:       $settings->update_settings_values( $value );
233:       $settings_option->values[$name] = $settings;
234:     }
235:   }
236: 
237:   /**
238:    */
239:   function update_settings() {
240:     $this->_is_dirty = true;
241:   }
242: 
243:   /**
244:    * @param object $settings_option
245:    * @param bool $set_dirty
246:    * @return array
247:    */
248:   function update_settings_option( $settings_option, $set_dirty = true ) {
249:     if ( is_a( $this->_parent, __CLASS__ ) ) {
250:       $this->configured = $settings_option->configured;
251:       $this->installed_version = $settings_option->installed_version;
252:       $this->update_settings_array( $settings_option->values );
253:       if ( $set_dirty )
254:         $this->_is_dirty = true;
255:     }
256:   }
257: 
258:   /**
259:    * @param array $required_settings
260:    */
261:   function set_required_setting_names( $required_settings ) {
262:     $this->_required_settings = $required_settings;
263:   }
264: 
265:   /**
266:    * @param bool|array $required_setting_names
267:    *
268:    * @return bool
269:    */
270:   function has_required_settings( $required_setting_names = false ) {
271:     $has_required_settings = true;
272:     if ( $required_setting_names )
273:       $this->set_required_setting_names( $required_setting_names );
274: 
275:     /** @var Sidecar_Form $form */
276:     foreach( $this->_required_settings as $setting_name ) {
277:       if ( empty( $this->_settings_values[$setting_name] ) ) {
278:         $has_required_settings = false;
279:         break;
280:       }
281:     }
282:     if ( method_exists( $this, 'filter_has_required_settings' ) ) {
283:       $has_required_settings = $this->filter_has_required_settings( $has_required_settings, $this );
284:     }
285:     return $has_required_settings;
286:   }
287: 
288:   /**
289:    * @return array
290:    */
291:   function get_empty_settings_values() {
292:     return array_fill_keys( array_keys( $this->_settings_values ), '' );
293:   }
294: 
295:   /**
296:    * @return bool
297:    */
298:   function is_dirty() {
299:     return $this->_is_dirty;
300:   }
301: 
302:   /**
303:    * @return array
304:    */
305:   function get_settings_array() {
306:     if ( ! $this->_parent instanceof Sidecar_Plugin_Base ) {
307:       $array = $this->get_settings_values();
308:     } else {
309:       $array = array();
310:       /**
311:        * @var Sidecar_Settings $value
312:        */
313:       foreach( $this->_settings_values as $name => $value )
314:         $array[$name] = $value->get_settings_values();
315:     }
316:     return $array;
317:   }
318: 
319:   /**
320:    * Save settings if parent is Sidecar_Plugin_Base
321:    *
322:    */
323:   function save_settings() {
324:     if ( $this->_parent instanceof Sidecar_Plugin_Base ) {
325: 
326:       // @todo Sure default values for settings array here.
327: 
328:       update_option( $this->option_name, (object)array(
329:         'installed_version' => $this->installed_version,
330:         'configured'        => $this->configured,
331:         'values'            => $this->get_settings_array(),
332:       ));
333:     }
334:   }
335: 
336:   /**
337:    * Load settings if parent is Sidecar_Plugin_Base
338:    *
339:    */
340:   function load_settings() {
341:     if ( $this->_parent instanceof Sidecar_Plugin_Base ) {
342: 
343:       $option = get_option( $this->option_name );
344: 
345:       if ( ! empty( $option->values ) && is_array( $option->values ) )
346:         $this->initialize_settings( $option->values );
347:       if ( ! empty( $option->configured ) && is_bool( $option->configured ) )
348:         $this->configured = $option->configured;
349:       if ( ! empty( $option->installed_version ) )
350:         $this->installed_version = $option->installed_version;
351: 
352:     }
353:   }
354: 
355:   /**
356:    *
357:    */
358:   function delete_settings() {
359:     delete_option( $plugin->option_name );
360:   }
361: 
362: }
363: 
API documentation generated by ApiGen 2.8.0