Textpattern Forum

You are not logged in. Register | Login | Help

#91 2010-03-17 11:50:35

THE BLUE DRAGON
Member
From: Israel
Registered: 2007-11-16
Posts: 542
Website

Re: [plugin] [ORPHAN] cbs_live_search

whaleen wrote:

How to limit search to one section?

Take a look 6 posts above

Offline

#92 2010-03-17 19:01:28

whaleen
Member
From: Portland
Registered: 2006-05-11
Posts: 372
Website

Re: [plugin] [ORPHAN] cbs_live_search

Take a look 6 posts above

I cannot do that. Sections should be searchable on demand. Some instances I need to only search one section and in others other sections. An example attribute would be limit_search_to_section and it’s value could be a single section name or multiple comma separated.

Example:

<txp:cbs_live_search limit_search_to_section="people" />

If:

Someone who was willing could develop the plugin further to have this functionality.

Then:

Feature requests:

  • limit_search_to_section attribute
  • form attribute (use a form to output results)

txtstrap (Textpattern + Twitter Bootstrap + etc…)

Offline

#93 2010-03-30 09:38:46

mrjysta
Member
Registered: 2008-09-22
Posts: 89

Re: [plugin] [ORPHAN] cbs_live_search

Yes also the ability to search specific categories would also be great, the plug-in works nice but keeps bringing up headings and items which are unwanted as a user searching the site. i.e. just searching articles in ‘blog’ section with a category of ‘design’ :

<txp:cbs_live_search cbs_section=“blog” cbs_category=“design” />

Offline

#94 2012-03-08 10:04:51

kvnmcwebn
Member
From: Ireland
Registered: 2007-01-27
Posts: 724
Website

Re: [plugin] [ORPHAN] cbs_live_search

I started using this because live search stopped working after my last upgrade. It works fine but I really wish there was some info that showed up in the visitor logs after a user does a search. That was a nice feature in live search.


its a bad hen that wont scratch itself.
photogallery

Offline

#95 2012-05-11 21:19:20

etc
Plugin Author
Registered: 2010-11-11
Posts: 1,230
Website

Re: [plugin] [ORPHAN] cbs_live_search

EDIT: Don’t take the code from this post, there’s a link to the plugin’s own topic one post below!

I have tweaked this plugin some time ago to enable more elaborated searches. In its simplest form it treats a search string like term1 !term2, term3 as (term1 AND NOT term2) OR term3, but you can implement your own rules and query for virtually any information in your database. I have not modified the original plugin’s help, but if someone is interested, I could post it here.

Plugin code:

a:11:{s:4:"name";s:15:"cbs_live_search";s:6:"author";s:16:"Christophe Beyls";s:10:"author_uri";s:23:"http://www.digitalia.be";s:7:"version";s:4:"0.8b";s:11:"description";s:0:"";s:4:"help";s:14886:"	<h3>Description</h3>

	<p>This plugin displays a search box similarly to <code>&lt;txp:search_input /&gt;</code>. If Javascript is enabled, a results list will fade in and resize in real time below the search box with a nice animation effect as the user types his query.</p>

	<p>Optionaly, a clickable image can be displayed at the right of the search box to clear its content. When the search box is empty or contains less than 3 characters, the results list shrinks and fades out.</p>

	<p>Also, an image (such as a spinner) can be displayed at the right of the search box when a search is in progress, and disappears when the results are shown.</p>

	<p>When the user hits the Enter key he gets redirected to a traditional search results page, so the plugin also degrades nicely in non-Javascript browsers.</p>

	<h3>Requirements</h3>

	<p>Since version 0.8, cbs_live_search can use either the <a href="http://jquery.com/">jQuery</a> or <a href="http://mootools.net/">MooTools</a> javascript framework.<br />
<strong>Just pick your favorite one:</strong></p>

	<h4>jQuery</h4>

	<p>jQuery <strong>1.2</strong> or more recent is required.</p>

	<p>You can use the <code>jquery.js</code> javascript file which is bundled with Textpattern and you need to upload the provided <code>livesearch.jquery.js</code> file to your web server (for example in a folder called &#8220;/js/&#8221;) and include both of these files in the header of the web pages where you want to use the plugin:</p>

<pre><code>&lt;script type=&quot;text/javascript&quot; src=&quot;/textpattern/jquery.js&quot;&gt;&lt;/script&gt;
&lt;script type=&quot;text/javascript&quot; src=&quot;/js/livesearch.jquery.js&quot;&gt;&lt;/script&gt;
</code></pre>

	<p><em>Remarks:</em>
	<ol>
		<li>If you are already using jQuery, don&#8217;t include it twice!</li>
		<li>If you also use other javascript frameworks (Prototype, Dojo, <span class="caps">YUI</span>, etc.), it is recommended that you include jQuery <em>first</em>. cbs_live_search is also compatible with the <a href="http://docs.jquery.com/Core/jQuery.noConflict">jQuery.noConflict()</a> mode.</li>
	</ol></p>

	<h4>MooTools</h4>

	<p>MooTools <strong>1.2</strong> or more recent is required. Because MooTools is modular, you can make your download smaller by only downloading the modules that your scripts are actually using, thanks to the <a href="http://mootools.net/core">Core Builder</a>. Here are the MooTools Core modules required by cbs_live_search:</p>

	<ul>
		<li><strong>Native:</strong> all</li>
		<li><strong>Class:</strong> all</li>
		<li><strong>Element:</strong> Element.Event, Element.Style</li>
		<li><strong>Fx:</strong> Fx.Morph</li>
		<li><strong>Request:</strong> Request</li>
	</ul>

	<p>The cbs_live_search plugin comes bundled with a file named <code>mootools.js</code> which contains these minimal dependencies only. This ensures the smallest download size for your visitors if you don&#8217;t use MooTools or jQuery at all for other features on your public website.</p>

	<p>You need to upload the javascript files <code>mootools.js</code> and the provided <code>livesearch.mootools.js</code> to your web server (for example in a folder called &#8220;/js/&#8221;) and include them in the header of the web pages where you want to use the plugin:</p>

<pre><code>&lt;script type=&quot;text/javascript&quot; src=&quot;/js/mootools.js&quot;&gt;&lt;/script&gt;
&lt;script type=&quot;text/javascript&quot; src=&quot;/js/livesearch.mootools.js&quot;&gt;&lt;/script&gt;
</code></pre>

	<p><em>Remarks:</em>
	<ol>
		<li>If you are already using MooTools, don&#8217;t include it twice!</li>
		<li>If you use the <a href="http://www.prototypejs.org/">Prototype</a> framework for other scripts, include it <em>before</em> MooTools.</li>
	</ol></p>

	<h3>Syntax</h3>

<pre><code>&lt;txp:cbs_live_search /&gt;
</code></pre>

	<h3>Attributes</h3>

	<h4>Required</h4>

	<p>none.</p>

	<h4>Optional</h4>

	<ul>
		<li><strong>section</strong>: Name of the section to redirect the user to when he hits the Enter key, in order to display the standard search results page. Default is the <code>default</code> section (home page).</li>
		<li><strong>html_id</strong>: <span class="caps">HTML</span> <code>id</code> attribute that will be applied to the search form. Default is <code>live_search</code>. You need to set this attribute to different values if you use more than one live search box inside the same web page.</li>
		<li><strong>label</strong>: Displays a label above the search box with the specified text. Default is no label.</li>
		<li><strong>size</strong>: Size of the search box (number of characters). Default is <code>15</code>.</li>
		<li><strong>default_value</strong>: Invitation text that will de displayed in the box when Javascript is enabled. This text disappears when the box gets the focus or when the user has typed something into it. Default is empty.</li>
		<li><strong>wraptag</strong>: <span class="caps">HTML</span> tag to wrap the optional label, the search field and the reset and wait images with, inside the form. Default is <code>p</code> (a paragraph).</li>
		<li><strong>safari</strong>: When set to <code>true</code>, the classic input box will be replaced by a Mac OS X search widget in Safari if Javascript is enabled. The reset image (see the <span class="caps">CSS</span> Styling section) will then <strong>never</strong> be displayed in these browsers. Other browsers will see the classic input box. Default is <code>false</code>.</li>
		<li><strong>results_break</strong>: <span class="caps">HTML</span> tag to be used for line breaks in the content inside the live results list, without brackets. Default is <code>br</code>.</li>
		<li><strong>results_wraptag</strong>: <span class="caps">HTML</span> tag to be used as the wraptag for the content inside the live results list, without brackets. Default is <code>p</code>.</li>
		<li><strong>results_max</strong>: Maximum number of results in the live results list. Default is <code>5</code>.</li>
		<li><strong>results_excerpts</strong>: When set to <code>true</code>, displays excerpts of the articles containing the search terms. Search terms will be wrapped in <code>&lt;strong&gt;</code> tags. Default is <code>false</code>.</li>
		<li><strong>results_dates</strong>: When set to <code>true</code>, displays the article date at the bottom of each result entry. Default is <code>false</code>.</li>
		<li><strong>no_results</strong>: Text that will be displayed in the live results list when no articles are found. Default is &#8220;0 articles found&#8221; localized in the language of your Textpattern installation.</li>
	</ul>

	<h3><span class="caps">CSS</span> Styling</h3>

	<p>The live search consists of a form with the default <code>id</code> attribute value &#8220;live_search&#8221; (which can be changed using the &#8220;html_id&#8221; parameter). This form contains two zones. You can style any element by referencing the id attribute of the form and the <span class="caps">CSS</span> class of the element (or its tag) in your <span class="caps">CSS</span>.</p>

	<p>If you define a label, you can choose to make it invisible by setting its display property to &#8220;none&#8221; in the <span class="caps">CSS</span>, so it will only be displayed in non-<span class="caps">CSS</span> browsers that will usually not be able to display the text of the &#8220;default_value&#8221; parameter (see above).</p>

	<p><em>Example:</em></p>

<pre><code>#live_search label {
    display: none;
}
</code></pre>

	<h4>The search zone</h4>

	<p>The first zone is a block with the applied class &#8220;ls_search&#8221; which contains: the optional label (followed by a line break if defined), the text input box and the reset and wait images. The tag of this block is defined by the &#8220;wraptag&#8221; parameter (de fault is <code>p</code>).</p>

	<p>The search box is an input tag. If you want, you can style it using a <span class="caps">CSS</span> rule like this one:</p>

<pre><code>#live_search input {
    font-size: 10px;
    color: #000;
}
</code></pre>

	<p>When the search box is inactive (empty with no focus), the &#8220;ls_inactive&#8221; class is applied to it, so you can style it differently while it is in this state, typically by making the font brighter.</p>

	<p><em>Example:</em></p>

<pre><code>#live_search input.ls_inactive {
    color: #666;
}
</code></pre>

	<p>If you set the &#8220;safari&#8221; parameter to <code>true</code> and the browser is detected as Safari, the seach box will be replaced by a Mac OS X search widget and the reset image will not be shown because this special search widget already has one, and the &#8220;ls_safari&#8221; class will be applied to the <strong>form</strong>. This allows you to style the form and its subelements differently when displaying the Mac widget, for example by making the search widget larger because you know that the reset image will not be shown.</p>

	<p>Immediately to the right of the search box, still inside the block, you have the reset image and then the wait image. These images are facultative and must be defined using <span class="caps">CSS</span> if you want to use them. If you don&#8217;t declare any <span class="caps">CSS</span> rule for one of these images, it will never appear.</p>

	<p>The reset image is a <code>&lt;span&gt;</code> tag with the class &#8220;ls_reset_image&#8221; which is visible when the search box is not empty. Clicking on this image will clear the search box like a reset button. Note that even if you define a <span class="caps">CSS</span> rule for a reset image, it will never be displayed in Safari browsers when the &#8220;safari&#8221; parameter is set to <code>true</code> (see above).</p>

	<p>The wait image is a <code>&lt;span&gt;</code> tag with the class &#8220;ls_wait_image&#8221; which is visible only during a search operation and disappears as soon as the results are shown. Typically, this image is a spinner or a hourglass.</p>

	<p>When you define the <span class="caps">CSS</span> rules for these images, you <strong>must</strong>:</p>

	<ul>
		<li>Set the display property to &#8220;inline-block&#8221;,</li>
		<li>Set the width and height properties to the width and height of the image (in pixels),</li>
		<li>Set the background property to the image file <span class="caps">URL</span>,</li>
		<li>For the reset image only, set the cursor property to &#8220;pointer&#8221; so that the mouse cursor indicates to the user that it works like a button.</li>
	</ul>

	<p>Also, it is a good idea to define a margin for some of these elements in order to add some space between the input box and the images.</p>

	<p><em>Example:</em></p>

<pre><code>#live_search .ls_reset_image
{
    display: inline-block;
    width: 14px;
    height: 14px;
    background: transparent url(../img/reset.gif) no-repeat center;
    cursor: pointer;
    margin-left: 10px;
}
</code></pre>

<pre><code>#live_search .ls_wait_image
{
    display: inline-block;
    width: 16px;
    height: 16px;
    background: transparent url(../img/spinner.gif) no-repeat center;
    margin-left: 10px;
}
</code></pre>

	<p><strong>Remark:</strong> Browsers using previous versions of the Gecko engine like Firefox 1 or 2 normally do not support the &#8220;inline-block&#8221; value but cbs_live_search includes a javascript fix to make it work in these browsers, so you don&#8217;t need to worry about it.</p>

	<p>Ensure that you have enough space to display all elements of this block in the same row (by using correctly sized images and setting elements margins and the search box width with correct values for example).</p>

	<h4>The results zone</h4>

	<p>The results zone is a <code>&lt;div&gt;</code> block with the class &#8220;ls_results&#8221;, containing the results list.</p>

	<p>You can choose to style this <code>&lt;div&gt;</code> block as you want, but they are a few constraints:</p>

	<ol>
		<li>You <strong>must</strong> set a non-transparent background for it (a color and optionnaly an image), otherwise if you keep the default transparent background, the div will display wrong in Internet Explorer.</li>
		<li>You <strong>must</strong> set the &#8220;overflow&#8221; property to &#8220;hidden&#8221;, otherwise the effect will not work as expected.</li>
		<li>You <strong>must</strong> set the &#8220;width&#8221; OR &#8220;height&#8221; of the <code>&lt;div&gt;</code> block (not both). If you set the width, ensure that it can expand vertically. If you set the height, ensure that it can expand horizontally.</li>
		<li>You <strong>must not</strong> set its padding (leave it to zero, as it is by default), otherwise the script will not be able to compute the right size for the scale effect. Instead, you may set a margin for the content of the <code>&lt;div&gt;</code> block (see below how to style the content).</li>
		<li>You <strong>must not</strong> set &#8220;display&#8221; and &#8220;visibility&#8221; properties. The block will simply not appear at all when Javascript is disabled.</li>
	</ol>

	<p>You <strong>may</strong> set any border to any side. Enventually, you can choose to style this <code>&lt;div&gt;</code> block with an absolute position or not. If you choose absolute (specify <code>position: absolute;</code>), it will fade in above your page like a popup.</p>

	<p><em>Example 1 (normal positioning):</em></p>

<pre><code>#live_search .ls_results
{
    background-color: #ebebeb;
    overflow: hidden;
    width: 200px;
}
</code></pre>

	<p><em>Example 2 (absolute positioning):</em></p>

<pre><code>#live_search .ls_results
{
    position: absolute;
    left: 0;
    top: 0;
    background-color: #000;
    overflow: hidden;
    width: 500px;
    border: 1px solid #fff;
}
</code></pre>

	<p>The content of the results block will be either:</p>

	<ol>
		<li><em>At least one result is found:</em> A list with wrap and break tags according to your &#8220;wraptag&#8221; and &#8220;break&#8221; parameters (see above). The title of the articles will be wrapped in a link, so you can style the title differently from the (optional) excerpt based on the <code>&lt;a&gt;</code> tag (example: <code>#live_search .ls_results a:link, #live_search .ls_results a:visited { ... }</code>). The search expression will be wrapped in a <code>&lt;strong&gt;</code> tag inside the excerpts.</li>
		<li><em>No results found:</em> A message (according to the &#8220;noresults&#8221; parameter described above) wrapped in a paragraph (<code>&lt;p&gt;</code> tag).</li>
	</ol>

	<p>You can style the results content as you want with no limitations. It is recommended to set a margin because its container (the <code>&lt;div&gt;</code> block with the class &#8220;ls_results&#8221;) must not have any padding.</p>

	<p><em>Example:</em></p>

<pre><code>#live_search .ls_results p
{
    margin: 10px;
}
</code></pre>";s:4:"code";s:7067:"register_callback('cbs_search_results', 'textpattern');

function cbs_op_query($string,$fields,$ops=null)
{
  if(!$fields || !$string) return '0';
  $where=array();
  if(!$ops || !is_array($ops)) {
    $patterns = explode('|',$fields);
    $fields = array();
    $string = preg_replace('/^\\\"(.+)\\\"$/', '$1', $string);
    foreach($patterns as $pattern) {
      list($flds,$pat,$rep,$comp) = explode(':',$pattern) + array_fill(0,4,null);
      if(!isset($pat) || preg_match($pat,$string)) {
        if(empty($comp)) $comp = "LIKE '%*%'";
        $fields[] = array($flds, $comp);
        if(isset($rep)) $string = preg_replace($pat, $rep, $string);
      }
    }
    if(!$fields) return '0';
    $not = false;
    while($string && $string[0]=='!') {$not = !$not; $string=substr($string,1);}
    foreach($fields as $flist) {
    $whr=array();
    $flds = do_list($flist[0]);
    $comp = preg_replace("/\*/", $string, $flist[1]);
    if($not) {$not='NOT'; $op='AND';}
    else {$not=''; $op='OR';} 
    foreach($flds as $field) $whr[] ="$not $field $comp";
    $where[] = implode(" $op ",$whr);
    }
    return '('.implode(" $op ",$where).')';
  }

  @list($sep,$op) = explode(':',array_pop($ops));

  $separ = $sep."*".$sep;
  $string = preg_split('/(\\\".+\\\")/U', $string, null, PREG_SPLIT_DELIM_CAPTURE);
  foreach($string as $key=>$value) 
	if(!preg_match('/^\\\".+\\\"$/', $value)) $string[$key] = str_replace($sep, $separ, $value);
  $string = implode('', $string);

  foreach(do_list($string, $separ) as $value)
  {
    if(strlen($value)>1) $where[] = cbs_op_query($value,$fields,$ops);
  }
  switch (count($where)) {
  case 0:
    return '0';
  case 1:
    return $where[0];
  default:
    return '('.implode(" $op ",$where).')';
  }
  return '0';
}

function cbs_default_query(&$o, $q=null, $filter='', $limit='', $excerpts=null, $dates=null, $where=null)
{
if(!$q || $where==='0') return;
if(!$where) $where = "Title LIKE '%$q%' OR Body LIKE '%$q%'";
$rs = safe_rows(
    ($excerpts?"Body_html,":'')."ID, Title, Section, unix_timestamp(Posted) AS posted, MATCH (Title,Body) AGAINST ('$q') AS score",
    'textpattern',
    "($where)$filter AND Status >= 4 AND Posted <= now() AND (Expires='0000-00-00 00:00:00' OR Expires>=now()) ORDER BY score DESC".$limit
);

if($rs) {
  global $prefs;
  $concat = '';
  foreach($rs as $a) {
    $hurl = permlinkurl($a);

    if($excerpts) {
      $q = preg_quote(str_replace("'", '&#8217;', htmlspecialchars($q)), '/');
      $result = preg_replace('/>\s+</', '> <', $a['Body_html']);
      preg_match_all('/(?:^|\s).{0,50}'.$q.'.{0,50}(?:\s|$)/i', $result, $concat);
      $concat = join(' ... ', $concat[0]);
      $concat = strip_tags($concat);
      $concat = preg_replace('/(?:^[^>]*>|<[^<]*$)/U', '', $concat);
      $concat = preg_replace('/('.$q.')/i', '<strong>$1</strong>', $concat);
      if($concat) $concat = '<br />... '.$concat.' ...';
    }
    $o[] = '<a href="'.$hurl.'">'.$a['Title'].'</a>'.$concat
            .(($dates) ? '<br />&#8212; '.safe_strftime($prefs['archive_dateformat'], $a['posted']) : '');
  }
}
return;
}

function cbs_search_results($event, $step)
{
  if(($q = ps('q')) == '') {
      return;
  }

  $break = ps('b');
  $wraptag = ps('w');
  if(!($max = intval(ps('m')))) {
      $max = 5;
  }
  $limit = ($max<0?'':" LIMIT $max");
  $excerpts = ps('e');
  $dates = ps('d');
  $qhash = ps('h');
  $query = rawurldecode(ps('f'));
  $hash=get_pref('cbs_search_hash');
  header('Content-Type: text/xml');

  $q = trim($q);
  if(empty($q) || !preg_match("/\w/",$q) || $qhash != md5($hash.$query)) {
      exit('<none />');
  }
  $o = array();
  
//$o[]="<!-- $query $qhash ".md5($hash.$query)." -->";
  $q2 = addcslashes($q, '\'"\\%_');
//$o[] = $q2;

  $rs = safe_column('name', 'txp_section', "searchable != '1'");
  if($rs) {
      foreach($rs as $name) {
          $filters[] = " AND Section != '$name'";
      }
      $s_filter = join('', $filters);
  } else {
      $s_filter = '';
  }

    $ops=explode('|',get_pref('cbs_search_ops'));
//  $ops=array(' :AND',',:OR');

  foreach(explode('|||', $query) as $qry) {
    list($what, $where, $form) = explode('||', $qry) + array_fill(0,3,null);
    list($filter, $fields, $table, $sort) = explode(':', $what) + array_fill(0,4,null);
    if($where) $where = cbs_op_query($q2,$where,$ops);

//$o[]="$where";

    if(!$fields || !$table) {cbs_default_query($o, $q2, $s_filter.($filter?" AND ($filter)":''), $limit, $excerpts, $dates, $where);}
    else if($where && $form) {
      $rs = safe_rows(
          $fields,
          $table,
          "($where)".($table=='textpattern'?$s_filter:'').($filter?" AND ($filter)":'').($sort?" ORDER BY $sort":'')
      );
      if($rs) {
        $form = preg_replace('/{(.+)}/U', "\$a[$1]", $form);
        eval("foreach(\$rs as \$a) \$o[] = \"$form\";");
      }
    }
  }
  
  if(!count($o)) {
      exit('<none />');
  }
  echo('<?xml version=\'1.0\' encoding=\'utf-8\' ?>');
  exit(doWrap($o, $wraptag, $break));
}

function cbs_live_search($atts)
{
  extract(lAtts(array(
      'section'         => false,
      'html_id'         => 'live_search',
      'label'           => false,
      'size'            => 15,
      'default_value'   => '',
      'wraptag'         => 'p',
      'query'           => '||Title,Body',
      'safari'          => false,
      'results_break'   => 'br',
      'results_wraptag' => 'p',
      'results_max'     => false,
      'results_excerpts'=> false,
      'results_dates'   => false,
      'no_results'      => '0 '.gTxt('articles_found')
  ),$atts));
  $section = $section ? pagelinkurl(array('s'=>$section)) : rhu;
  $safari = ($safari == 'true') ? 1 : 0;
  if(!($hash = get_pref('cbs_search_hash', null))) {
    $hash = md5(mt_rand());
    set_pref('cbs_search_hash', $hash, 'cbs_search', PREF_HIDDEN);
  }
  if(!get_pref('cbs_search_ops')) 
    set_pref('cbs_search_ops', ' :AND|,:OR', 'cbs_search', PREF_HIDDEN);
  $results_opts = array();
  if($results_break) $results_opts[] ='b:"'.$results_break.'"';
  if($results_wraptag) $results_opts[] = 'w:"'.$results_wraptag.'"';
  if($results_max) $results_opts[] = 'm:'.$results_max;
  if($results_excerpts) $results_opts[] = 'e:1';
  if($results_dates) $results_opts[] = 'd:1';
  if($query) {$results_opts[] ='h:"'.md5($hash.$query).'"'; $results_opts[] ='f:"'.rawurlencode($query).'"';}

  return '<form id="'.$html_id.'" method="get" action="'.$section.'">'.n
      .doTag( ($label ? '<label>'.$label.'<br /></label>' : '')
      .'<input type="search" name="q" size="'.$size.'" placeholder="'.$default_value.'" autocomplete="off" autofocus />', $wraptag, "ls_search" ).n.'</form>'
      .'<script type="text/javascript">//<![CDATA['.n.'$(function () {'.n.'cbs_live_search("'.$html_id.'","'.$default_value
      .'","'.$no_results.'",'.$safari.',{'.join(',', $results_opts).'});});'.n.'//]]></script>';
}";s:4:"type";s:1:"0";s:5:"order";s:1:"9";s:5:"flags";s:1:"0";s:3:"md5";s:32:"2dcb4d27fb23c4ce36693e68dcbd958a";}

Javascript:

/*
	cbs_live_search v0.8 for jQuery 1.2
	(c) 2006-2008 Christophe Beyls <http://www.digitalia.be>
	MIT-style licence
*/
var cbs_live_search=(function(d){var f="",q,a,m,n,p,b,o,c,r,h,j;function g(){o.value="";k();o.focus()}function e(){clearTimeout(n);i(r);if(a){a=0;d(h).hide(600)}}function i(t,s){if(t){return t.css("visibility",s?"":"hidden")}}function k(){var s=o.value;if(s!=f){f=s;i(c,s);s=d.trim(s);if(s!=q.q){if(b){b.abort()}if((q.q=s).length<3){e()}else{i(r,1);b=d.ajax(d.extend(p,{data:q}))}}}}function l(){var s={width:j.clientWidth,height:j.clientHeight};if(!a){a=1;d(h).queue(function(){d(h).css(s).dequeue()}).show(600)}else{d(h).animate(s,600)}}return function(v,s,u,w,t){u="<p>"+u+"</p>";q=t;v=d("#"+v).append(d([j=i(d("<div />")).css("position","absolute")[0],h=d("<div />").css("display","none")[0]]).addClass("ls_results"))[0];o=d("input",v).focus(function(){if(d(o).hasClass("ls_inactive")){d(o).removeClass("ls_inactive");o.value=""}m=setTimeout(k,1000)}).blur(function(){clearTimeout(m);k();if(!o.placeholder&&(o.value=="")){d(o).addClass("ls_inactive");o.value=s}}).keyup(function(x){if(x.keyCode==27){g()}else{clearTimeout(m);m=setTimeout(k,600)}})[0];r=i(d('<span class="ls_wait_image" />')).insertAfter(o);c=!w&&i(d('<span class="ls_reset_image" />')).click(g).insertAfter(o);if(d.browser.mozilla&&!document.getElementsByClassName){r.add(c).css("display","-moz-inline-stack")}d(o).attr({autocomplete:"off"});if(!o.placeholder){d(o).attr({value:s}).addClass("ls_inactive")}p={url:v.action,type:"POST",dataType:"html",success:function(x){clearTimeout(n);i(r);d([j,h]).html((x=="<none />")?u:x);n=setTimeout(l,50)},error:e}}})(jQuery);

Last edited by uli (2012-11-14 20:55:03)


etc_[ query | search | pagination | date | tree | url ]

Offline

#96 2012-10-08 16:08:04

etc
Plugin Author
Registered: 2010-11-11
Posts: 1,230
Website

Re: [plugin] [ORPHAN] cbs_live_search

etc_search is out.

mrjysta wrote:

Yes also the ability to search specific categories would also be great : <txp:cbs_live_search cbs_section="blog" cbs_category="design" />

This is possible with etc_search:

<txp:etc_search query="{Title,Body} AND Section='blog' AND (Category1='design' OR Category2='design')" />

Last edited by etc (2012-10-08 19:40:45)


etc_[ query | search | pagination | date | tree | url ]

Offline

Board footer

Powered by FluxBB