css_util.h

Go to the documentation of this file.

/*
 * Copyright 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_CSS_UTIL_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_CSS_UTIL_H_

#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace Css {
class Declarations;
class MediaQueries;
class MediaQuery;
class Selector;
}

namespace net_instaweb {

class HtmlElement;

namespace css_util {

static const char kAllMedia[] = "all";
static const int kNoValue = -1;

enum DimensionState {
  kNoDimensions,       
  kHasHeightOnly,      
  kHasWidthOnly,       
  kHasBothDimensions,  
  kNotParsable         
};

DimensionState GetDimensions(Css::Declarations* decls, int* width, int* height);

class StyleExtractor {
 public:
  explicit StyleExtractor(HtmlElement* element);
  virtual ~StyleExtractor();


  DimensionState state() const { return state_; }

  int width() const { return width_px_; }
  int height() const { return height_px_; }

  bool HasAnyDimensions() { return (state_ != kNoDimensions); }

  DimensionState dimension_state() { return state_; }

 private:
  static Css::Declarations* GetDeclsFromElement(HtmlElement* element);
  scoped_ptr<Css::Declarations> decls_;
  int width_px_;
  int height_px_;
  DimensionState state_;
  
};


void VectorizeMediaAttribute(const StringPiece& input_media,
                             StringVector* output_vector);

GoogleString StringifyMediaVector(const StringVector& import_media);

bool IsComplexMediaQuery(const Css::MediaQuery& query);

bool ConvertMediaQueriesToStringVector(const Css::MediaQueries& in_vector,
                                       StringVector* out_vector);

void ConvertStringVectorToMediaQueries(const StringVector& in_vector,
                                       Css::MediaQueries* out_vector);

void ClearVectorIfContainsMediaAll(StringVector* media);

bool CanMediaAffectScreen(const StringPiece& media);

GoogleString JsDetectableSelector(const Css::Selector& selector);

template<typename T>
void EliminateElementsNotIn(std::vector<T>* sorted_inner,
                            const std::vector<T>& sorted_outer) {
  if (!sorted_outer.empty()) {
    if (sorted_inner->empty()) {
      *sorted_inner = sorted_outer;
    } else {
      typename std::vector<T>::const_iterator outer_iter = sorted_outer.begin();
      typename std::vector<T>::iterator inner_iter = sorted_inner->begin();

      while (inner_iter != sorted_inner->end()) {
        if (outer_iter == sorted_outer.end()) {
          inner_iter = sorted_inner->erase(inner_iter, sorted_inner->end());
        } else if (*outer_iter == *inner_iter) {
          ++outer_iter;
          ++inner_iter;
        } else if (*outer_iter < *inner_iter) {
          ++outer_iter;
        } else {
          inner_iter = sorted_inner->erase(inner_iter);
        }
      }
    }
  }
}

}  

}  

#endif