File indexing completed on 2024-05-05 17:34:14

 /* SPDX-FileCopyrightText: 1999-2001 Lubos Lunak <l.lunak@kde.org>
    SPDX-FileCopyrightText: 2008 Michael Jansen <kde@michael-jansen.biz>
 
    SPDX-License-Identifier: GPL-2.0-only
 */
 
 #include "windows_helper/window_selection_rules.h"
 
 #include <KLocalizedString>
 #include <QDebug>
 
 namespace KHotKeys
 {
 Windowdef_simple::Windowdef_simple(const QString &comment_P,
                                    const QString &title_P,
                                    substr_type_t title_type_P,
                                    const QString &wclass_P,
                                    substr_type_t wclass_type_P,
                                    const QString &role_P,
                                    substr_type_t role_type_P,
                                    int window_types_P)
     : Windowdef(comment_P)
     , _title(title_P)
     , _title_match_type(title_type_P)
     , _wclass(wclass_P)
     , _wclass_match_type(wclass_type_P)
     , _role(role_P)
     , _role_match_type(role_type_P)
     , _window_types(window_types_P)
 {
 }
 
 Windowdef_simple::Windowdef_simple(KConfigGroup &cfg_P)
     : Windowdef(cfg_P)
 {
     _title = cfg_P.readEntry("Title");
     _title_match_type = static_cast<substr_type_t>(cfg_P.readEntry("TitleType", 0));
     _wclass = cfg_P.readEntry("Class");
     _wclass_match_type = static_cast<substr_type_t>(cfg_P.readEntry("ClassType", 0));
     _role = cfg_P.readEntry("Role");
     _role_match_type = static_cast<substr_type_t>(cfg_P.readEntry("RoleType", 0));
     _window_types = cfg_P.readEntry("WindowTypes", 0);
 }
 
 void Windowdef_simple::cfg_write(KConfigGroup &cfg_P) const
 {
     base::cfg_write(cfg_P);
     cfg_P.writeEntry("Title", title());
     cfg_P.writeEntry("TitleType", int(_title_match_type));
     cfg_P.writeEntry("Class", wclass());
     cfg_P.writeEntry("ClassType", int(_wclass_match_type));
     cfg_P.writeEntry("Role", role());
     cfg_P.writeEntry("RoleType", int(_role_match_type));
     cfg_P.writeEntry("WindowTypes", window_types());
     cfg_P.writeEntry("Type", "SIMPLE"); // overwrites value set in base::cfg_write()
 }
 
 Windowdef_simple *Windowdef_simple::copy() const
 {
     return new Windowdef_simple(comment(), title(), title_match_type(), wclass(), wclass_match_type(), role(), role_match_type(), window_types());
 }
 
 const QString Windowdef_simple::description() const
 {
     return i18n("Window simple: ") + comment();
 }
 
 bool Windowdef_simple::is_substr_match(const QString &str1_P, const QString &str2_P, substr_type_t type_P)
 {
     switch (type_P) {
     case NOT_IMPORTANT:
         return true;
     case CONTAINS:
         return str1_P.contains(str2_P) > 0;
     case IS:
         return str1_P == str2_P;
     case REGEXP: {
         QRegExp rg(str2_P);
         return rg.indexIn(str1_P) >= 0;
     }
     case CONTAINS_NOT:
         return str1_P.contains(str2_P) == 0;
     case IS_NOT:
         return str1_P != str2_P;
     case REGEXP_NOT: {
         QRegExp rg(str2_P);
         return rg.indexIn(str1_P) < 0;
     }
     }
     return false;
 }
 
 bool Windowdef_simple::match(const Window_data &window_P)
 {
     if (!type_match(window_P.type))
         return false;
     if (!is_substr_match(window_P.title, title(), _title_match_type))
         return false;
     if (!is_substr_match(window_P.wclass, wclass(), _wclass_match_type))
         return false;
     if (!is_substr_match(window_P.role, role(), _role_match_type))
         return false;
     qDebug() << "window match:" << window_P.title << ":OK";
     return true;
 }
 
 const QString &Windowdef_simple::role() const
 {
     return _role;
 }
 
 Windowdef_simple::substr_type_t Windowdef_simple::role_match_type() const
 {
     return _role_match_type;
 }
 
 void Windowdef_simple::set_title(const QString &title)
 {
     _title = title;
 }
 
 void Windowdef_simple::set_title_match_type(const substr_type_t &type)
 {
     _title_match_type = type;
 }
 
 void Windowdef_simple::set_role(const QString &role)
 {
     _role = role;
 }
 
 void Windowdef_simple::set_role_match_type(const substr_type_t &type)
 {
     _role_match_type = type;
 }
 
 void Windowdef_simple::set_window_types(const int types)
 {
     _window_types = types;
 }
 
 void Windowdef_simple::set_wclass(const QString &wclass)
 {
     _wclass = wclass;
 }
 
 void Windowdef_simple::set_wclass_match_type(const substr_type_t &type)
 {
     _wclass_match_type = type;
 }
 
 const QString &Windowdef_simple::title() const
 {
     return _title;
 }
 
 Windowdef_simple::substr_type_t Windowdef_simple::title_match_type() const
 {
     return _title_match_type;
 }
 
 bool Windowdef_simple::type_match(window_type_t type_P) const
 {
     return window_types() & type_P;
 }
 
 bool Windowdef_simple::type_match(NET::WindowType type_P) const
 {
     return (window_types() & (1 << type_P)) || (type_P == NET::Unknown && (window_types() & WINDOW_TYPE_NORMAL));
     // CHECKME HACK haaaack !
 }
 
 const QString &Windowdef_simple::wclass() const
 {
     return _wclass;
 }
 
 Windowdef_simple::substr_type_t Windowdef_simple::wclass_match_type() const
 {
     return _wclass_match_type;
 }
 
 int Windowdef_simple::window_types() const
 {
     return _window_types;
 }
 
 } // namespace KHotKeys