├── .github └── workflows │ └── ci.yaml ├── .gitignore ├── CMakeLists.txt ├── FirefoxProfileRunner.kdev4 ├── LICENSE ├── Messages.sh ├── README.md ├── install.sh ├── postinst ├── postrm ├── src ├── CMakeLists.txt ├── Config.h ├── config │ ├── config_types.h │ ├── firefoxprofilerunner_config.cpp │ ├── firefoxprofilerunner_config.h │ └── firefoxprofilerunner_config.ui ├── firefoxprofilerunner.cpp ├── firefoxprofilerunner.h ├── firefoxprofilerunner.json.in ├── private_browsing_firefox.svg └── profile │ ├── Profile.cpp │ ├── Profile.h │ ├── ProfileManager.cpp │ └── ProfileManager.h ├── test ├── CMakeLists.txt ├── Config.h ├── ProfileManagerTest.cpp └── resources │ ├── firefox.desktop │ ├── profiles.ini │ └── profiles_install.ini └── uninstall.sh /.github/workflows/ci.yaml: -------------------------------------------------------------------------------- 1 | name: Build KRunner Plugins 2 | 3 | on: 4 | push: 5 | branches: 6 | - master 7 | - github_actions 8 | pull_request: 9 | branches: 10 | - master 11 | workflow_dispatch: 12 | inputs: 13 | publish-version: 14 | description: "new version that should get published" 15 | required: true 16 | permissions: 17 | contents: write 18 | 19 | jobs: 20 | build-and-publish: 21 | uses: alex1701c/actions/.github/workflows/plugin_ci_publish.yaml@main 22 | with: 23 | publish-version: ${{ inputs.publish-version }} 24 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /build* 2 | /.idea 3 | /.vscode 4 | /cmake-build-debug 5 | src/config/*.autosave 6 | src/config/ui_firefoxprofilerunner_config.h 7 | *.swap 8 | compile_commands.json 9 | .cache 10 | .clang-format 11 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.16) 2 | 3 | project(firefoxprofilerunner) 4 | 5 | set(CMAKE_PROJECT_VERSION "2.2.0") 6 | set(CMAKE_CXX_STANDARD 17) 7 | set(QT_MIN_VERSION 5.15.0) 8 | set(KF_MIN_VERSION 5.105.0) 9 | set(KDE_COMPILERSETTINGS_LEVEL "5.82.0") 10 | set(CMAKE_PROJECT_AUTHOR "alex1701c") 11 | set(CMAKE_PROJECT_AUTHOR_EMAIL "alex1701c.dev@gmx.net") 12 | 13 | find_package(ECM ${KF_MIN_VERSION} REQUIRED NO_MODULE) 14 | set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR} ${CMAKE_MODULE_PATH}) 15 | 16 | include(QtVersionOption) 17 | include(KDEInstallDirs) 18 | include(KDECMakeSettings) 19 | include(KDEClangFormat) 20 | include(ECMDeprecationSettings) 21 | include(ECMQtDeclareLoggingCategory) 22 | include(KDECompilerSettings NO_POLICY_SCOPE) 23 | include(FeatureSummary) 24 | 25 | find_package(Qt${QT_MAJOR_VERSION} ${QT_MIN_VERSION} REQUIRED CONFIG COMPONENTS Core Widgets) 26 | find_package(KF${QT_MAJOR_VERSION} ${KF_MIN_VERSION} REQUIRED COMPONENTS I18n Service Runner KCMUtils) 27 | 28 | ecm_set_disabled_deprecation_versions( 29 | QT ${QT_MIN_VERSION} 30 | KF ${KF_MIN_VERSION} 31 | ) 32 | 33 | feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES) 34 | 35 | add_subdirectory(src) 36 | if(BUILD_TESTING) 37 | add_subdirectory(test) 38 | endif() 39 | 40 | # CPack build 41 | set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Krunner plugin to launch firefox profiles") 42 | set(CPACK_PACKAGE_NAME krunner-${CMAKE_PROJECT_NAME}) 43 | set(CPACK_PACKAGE_VERSION "${CMAKE_PROJECT_VERSION}") 44 | set(CPACK_DEBIAN_PACKAGE_SECTION "utils") 45 | set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CMAKE_PROJECT_AUTHOR}") 46 | set(CPACK_RPM_PACKAGE_ARCHITECTURE "x86_64") 47 | 48 | set(KRUNNER_VERSION "${KF${QT_MAJOR_VERSION}Runner_VERSION}") 49 | set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_OS}-plasma${QT_MAJOR_VERSION}) 50 | if (CPACK_OS STREQUAL "ubuntu") 51 | set(CPACK_DEBIAN_PACKAGE_DEPENDS "libkf${QT_MAJOR_VERSION}runner${QT_MAJOR_VERSION} (>=${KRUNNER_VERSION})") 52 | set(CPACK_GENERATOR "DEB") 53 | elseif(CPACK_OS STREQUAL "opensuse" AND QT_MAJOR_VERSION STREQUAL 5) 54 | set(CPACK_RPM_PACKAGE_REQUIRES "libKF5Runner5 >= ${KRUNNER_VERSION}") 55 | set(CPACK_GENERATOR "RPM") 56 | elseif(CPACK_OS STREQUAL "fedora" OR CPACK_OS STREQUAL "opensuse") 57 | set(CPACK_RPM_PACKAGE_REQUIRES "kf${QT_MAJOR_VERSION}-krunner >= ${KRUNNER_VERSION}") 58 | set(CPACK_GENERATOR "RPM") 59 | else() 60 | unset(CPACK_PACKAGE_FILE_NAME) 61 | endif() 62 | 63 | 64 | set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_CURRENT_SOURCE_DIR}/postinst;${CMAKE_CURRENT_SOURCE_DIR}/postrm") 65 | set(CPACK_RPM_POST_INSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/postinst") 66 | set(CPACK_RPM_POST_UNINSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/postrm") 67 | INCLUDE(CPack) 68 | 69 | # add clang-format target for all our real source files 70 | file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h) 71 | kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES}) 72 | 73 | -------------------------------------------------------------------------------- /FirefoxProfileRunner.kdev4: -------------------------------------------------------------------------------- 1 | [Project] 2 | Manager=KDevCMakeManager 3 | Name=FirefoxProfileRunner 4 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU GENERAL PUBLIC LICENSE 2 | Version 3, 29 June 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | Preamble 9 | 10 | The GNU General Public License is a free, copyleft license for 11 | software and other kinds of works. 12 | 13 | The licenses for most software and other practical works are designed 14 | to take away your freedom to share and change the works. By contrast, 15 | the GNU General Public License is intended to guarantee your freedom to 16 | share and change all versions of a program--to make sure it remains free 17 | software for all its users. We, the Free Software Foundation, use the 18 | GNU General Public License for most of our software; it applies also to 19 | any other work released this way by its authors. You can apply it to 20 | your programs, too. 21 | 22 | When we speak of free software, we are referring to freedom, not 23 | price. Our General Public Licenses are designed to make sure that you 24 | have the freedom to distribute copies of free software (and charge for 25 | them if you wish), that you receive source code or can get it if you 26 | want it, that you can change the software or use pieces of it in new 27 | free programs, and that you know you can do these things. 28 | 29 | To protect your rights, we need to prevent others from denying you 30 | these rights or asking you to surrender the rights. Therefore, you have 31 | certain responsibilities if you distribute copies of the software, or if 32 | you modify it: responsibilities to respect the freedom of others. 33 | 34 | For example, if you distribute copies of such a program, whether 35 | gratis or for a fee, you must pass on to the recipients the same 36 | freedoms that you received. You must make sure that they, too, receive 37 | or can get the source code. And you must show them these terms so they 38 | know their rights. 39 | 40 | Developers that use the GNU GPL protect your rights with two steps: 41 | (1) assert copyright on the software, and (2) offer you this License 42 | giving you legal permission to copy, distribute and/or modify it. 43 | 44 | For the developers' and authors' protection, the GPL clearly explains 45 | that there is no warranty for this free software. For both users' and 46 | authors' sake, the GPL requires that modified versions be marked as 47 | changed, so that their problems will not be attributed erroneously to 48 | authors of previous versions. 49 | 50 | Some devices are designed to deny users access to install or run 51 | modified versions of the software inside them, although the manufacturer 52 | can do so. This is fundamentally incompatible with the aim of 53 | protecting users' freedom to change the software. The systematic 54 | pattern of such abuse occurs in the area of products for individuals to 55 | use, which is precisely where it is most unacceptable. Therefore, we 56 | have designed this version of the GPL to prohibit the practice for those 57 | products. If such problems arise substantially in other domains, we 58 | stand ready to extend this provision to those domains in future versions 59 | of the GPL, as needed to protect the freedom of users. 60 | 61 | Finally, every program is threatened constantly by software patents. 62 | States should not allow patents to restrict development and use of 63 | software on general-purpose computers, but in those that do, we wish to 64 | avoid the special danger that patents applied to a free program could 65 | make it effectively proprietary. To prevent this, the GPL assures that 66 | patents cannot be used to render the program non-free. 67 | 68 | The precise terms and conditions for copying, distribution and 69 | modification follow. 70 | 71 | TERMS AND CONDITIONS 72 | 73 | 0. Definitions. 74 | 75 | "This License" refers to version 3 of the GNU General Public License. 76 | 77 | "Copyright" also means copyright-like laws that apply to other kinds of 78 | works, such as semiconductor masks. 79 | 80 | "The Program" refers to any copyrightable work licensed under this 81 | License. Each licensee is addressed as "you". "Licensees" and 82 | "recipients" may be individuals or organizations. 83 | 84 | To "modify" a work means to copy from or adapt all or part of the work 85 | in a fashion requiring copyright permission, other than the making of an 86 | exact copy. The resulting work is called a "modified version" of the 87 | earlier work or a work "based on" the earlier work. 88 | 89 | A "covered work" means either the unmodified Program or a work based 90 | on the Program. 91 | 92 | To "propagate" a work means to do anything with it that, without 93 | permission, would make you directly or secondarily liable for 94 | infringement under applicable copyright law, except executing it on a 95 | computer or modifying a private copy. Propagation includes copying, 96 | distribution (with or without modification), making available to the 97 | public, and in some countries other activities as well. 98 | 99 | To "convey" a work means any kind of propagation that enables other 100 | parties to make or receive copies. Mere interaction with a user through 101 | a computer network, with no transfer of a copy, is not conveying. 102 | 103 | An interactive user interface displays "Appropriate Legal Notices" 104 | to the extent that it includes a convenient and prominently visible 105 | feature that (1) displays an appropriate copyright notice, and (2) 106 | tells the user that there is no warranty for the work (except to the 107 | extent that warranties are provided), that licensees may convey the 108 | work under this License, and how to view a copy of this License. If 109 | the interface presents a list of user commands or options, such as a 110 | menu, a prominent item in the list meets this criterion. 111 | 112 | 1. Source Code. 113 | 114 | The "source code" for a work means the preferred form of the work 115 | for making modifications to it. "Object code" means any non-source 116 | form of a work. 117 | 118 | A "Standard Interface" means an interface that either is an official 119 | standard defined by a recognized standards body, or, in the case of 120 | interfaces specified for a particular programming language, one that 121 | is widely used among developers working in that language. 122 | 123 | The "System Libraries" of an executable work include anything, other 124 | than the work as a whole, that (a) is included in the normal form of 125 | packaging a Major Component, but which is not part of that Major 126 | Component, and (b) serves only to enable use of the work with that 127 | Major Component, or to implement a Standard Interface for which an 128 | implementation is available to the public in source code form. A 129 | "Major Component", in this context, means a major essential component 130 | (kernel, window system, and so on) of the specific operating system 131 | (if any) on which the executable work runs, or a compiler used to 132 | produce the work, or an object code interpreter used to run it. 133 | 134 | The "Corresponding Source" for a work in object code form means all 135 | the source code needed to generate, install, and (for an executable 136 | work) run the object code and to modify the work, including scripts to 137 | control those activities. However, it does not include the work's 138 | System Libraries, or general-purpose tools or generally available free 139 | programs which are used unmodified in performing those activities but 140 | which are not part of the work. For example, Corresponding Source 141 | includes interface definition files associated with source files for 142 | the work, and the source code for shared libraries and dynamically 143 | linked subprograms that the work is specifically designed to require, 144 | such as by intimate data communication or control flow between those 145 | subprograms and other parts of the work. 146 | 147 | The Corresponding Source need not include anything that users 148 | can regenerate automatically from other parts of the Corresponding 149 | Source. 150 | 151 | The Corresponding Source for a work in source code form is that 152 | same work. 153 | 154 | 2. Basic Permissions. 155 | 156 | All rights granted under this License are granted for the term of 157 | copyright on the Program, and are irrevocable provided the stated 158 | conditions are met. This License explicitly affirms your unlimited 159 | permission to run the unmodified Program. The output from running a 160 | covered work is covered by this License only if the output, given its 161 | content, constitutes a covered work. This License acknowledges your 162 | rights of fair use or other equivalent, as provided by copyright law. 163 | 164 | You may make, run and propagate covered works that you do not 165 | convey, without conditions so long as your license otherwise remains 166 | in force. You may convey covered works to others for the sole purpose 167 | of having them make modifications exclusively for you, or provide you 168 | with facilities for running those works, provided that you comply with 169 | the terms of this License in conveying all material for which you do 170 | not control copyright. Those thus making or running the covered works 171 | for you must do so exclusively on your behalf, under your direction 172 | and control, on terms that prohibit them from making any copies of 173 | your copyrighted material outside their relationship with you. 174 | 175 | Conveying under any other circumstances is permitted solely under 176 | the conditions stated below. Sublicensing is not allowed; section 10 177 | makes it unnecessary. 178 | 179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 180 | 181 | No covered work shall be deemed part of an effective technological 182 | measure under any applicable law fulfilling obligations under article 183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or 184 | similar laws prohibiting or restricting circumvention of such 185 | measures. 186 | 187 | When you convey a covered work, you waive any legal power to forbid 188 | circumvention of technological measures to the extent such circumvention 189 | is effected by exercising rights under this License with respect to 190 | the covered work, and you disclaim any intention to limit operation or 191 | modification of the work as a means of enforcing, against the work's 192 | users, your or third parties' legal rights to forbid circumvention of 193 | technological measures. 194 | 195 | 4. Conveying Verbatim Copies. 196 | 197 | You may convey verbatim copies of the Program's source code as you 198 | receive it, in any medium, provided that you conspicuously and 199 | appropriately publish on each copy an appropriate copyright notice; 200 | keep intact all notices stating that this License and any 201 | non-permissive terms added in accord with section 7 apply to the code; 202 | keep intact all notices of the absence of any warranty; and give all 203 | recipients a copy of this License along with the Program. 204 | 205 | You may charge any price or no price for each copy that you convey, 206 | and you may offer support or warranty protection for a fee. 207 | 208 | 5. Conveying Modified Source Versions. 209 | 210 | You may convey a work based on the Program, or the modifications to 211 | produce it from the Program, in the form of source code under the 212 | terms of section 4, provided that you also meet all of these conditions: 213 | 214 | a) The work must carry prominent notices stating that you modified 215 | it, and giving a relevant date. 216 | 217 | b) The work must carry prominent notices stating that it is 218 | released under this License and any conditions added under section 219 | 7. This requirement modifies the requirement in section 4 to 220 | "keep intact all notices". 221 | 222 | c) You must license the entire work, as a whole, under this 223 | License to anyone who comes into possession of a copy. This 224 | License will therefore apply, along with any applicable section 7 225 | additional terms, to the whole of the work, and all its parts, 226 | regardless of how they are packaged. This License gives no 227 | permission to license the work in any other way, but it does not 228 | invalidate such permission if you have separately received it. 229 | 230 | d) If the work has interactive user interfaces, each must display 231 | Appropriate Legal Notices; however, if the Program has interactive 232 | interfaces that do not display Appropriate Legal Notices, your 233 | work need not make them do so. 234 | 235 | A compilation of a covered work with other separate and independent 236 | works, which are not by their nature extensions of the covered work, 237 | and which are not combined with it such as to form a larger program, 238 | in or on a volume of a storage or distribution medium, is called an 239 | "aggregate" if the compilation and its resulting copyright are not 240 | used to limit the access or legal rights of the compilation's users 241 | beyond what the individual works permit. Inclusion of a covered work 242 | in an aggregate does not cause this License to apply to the other 243 | parts of the aggregate. 244 | 245 | 6. Conveying Non-Source Forms. 246 | 247 | You may convey a covered work in object code form under the terms 248 | of sections 4 and 5, provided that you also convey the 249 | machine-readable Corresponding Source under the terms of this License, 250 | in one of these ways: 251 | 252 | a) Convey the object code in, or embodied in, a physical product 253 | (including a physical distribution medium), accompanied by the 254 | Corresponding Source fixed on a durable physical medium 255 | customarily used for software interchange. 256 | 257 | b) Convey the object code in, or embodied in, a physical product 258 | (including a physical distribution medium), accompanied by a 259 | written offer, valid for at least three years and valid for as 260 | long as you offer spare parts or customer support for that product 261 | model, to give anyone who possesses the object code either (1) a 262 | copy of the Corresponding Source for all the software in the 263 | product that is covered by this License, on a durable physical 264 | medium customarily used for software interchange, for a price no 265 | more than your reasonable cost of physically performing this 266 | conveying of source, or (2) access to copy the 267 | Corresponding Source from a network server at no charge. 268 | 269 | c) Convey individual copies of the object code with a copy of the 270 | written offer to provide the Corresponding Source. This 271 | alternative is allowed only occasionally and noncommercially, and 272 | only if you received the object code with such an offer, in accord 273 | with subsection 6b. 274 | 275 | d) Convey the object code by offering access from a designated 276 | place (gratis or for a charge), and offer equivalent access to the 277 | Corresponding Source in the same way through the same place at no 278 | further charge. You need not require recipients to copy the 279 | Corresponding Source along with the object code. If the place to 280 | copy the object code is a network server, the Corresponding Source 281 | may be on a different server (operated by you or a third party) 282 | that supports equivalent copying facilities, provided you maintain 283 | clear directions next to the object code saying where to find the 284 | Corresponding Source. Regardless of what server hosts the 285 | Corresponding Source, you remain obligated to ensure that it is 286 | available for as long as needed to satisfy these requirements. 287 | 288 | e) Convey the object code using peer-to-peer transmission, provided 289 | you inform other peers where the object code and Corresponding 290 | Source of the work are being offered to the general public at no 291 | charge under subsection 6d. 292 | 293 | A separable portion of the object code, whose source code is excluded 294 | from the Corresponding Source as a System Library, need not be 295 | included in conveying the object code work. 296 | 297 | A "User Product" is either (1) a "consumer product", which means any 298 | tangible personal property which is normally used for personal, family, 299 | or household purposes, or (2) anything designed or sold for incorporation 300 | into a dwelling. In determining whether a product is a consumer product, 301 | doubtful cases shall be resolved in favor of coverage. For a particular 302 | product received by a particular user, "normally used" refers to a 303 | typical or common use of that class of product, regardless of the status 304 | of the particular user or of the way in which the particular user 305 | actually uses, or expects or is expected to use, the product. A product 306 | is a consumer product regardless of whether the product has substantial 307 | commercial, industrial or non-consumer uses, unless such uses represent 308 | the only significant mode of use of the product. 309 | 310 | "Installation Information" for a User Product means any methods, 311 | procedures, authorization keys, or other information required to install 312 | and execute modified versions of a covered work in that User Product from 313 | a modified version of its Corresponding Source. The information must 314 | suffice to ensure that the continued functioning of the modified object 315 | code is in no case prevented or interfered with solely because 316 | modification has been made. 317 | 318 | If you convey an object code work under this section in, or with, or 319 | specifically for use in, a User Product, and the conveying occurs as 320 | part of a transaction in which the right of possession and use of the 321 | User Product is transferred to the recipient in perpetuity or for a 322 | fixed term (regardless of how the transaction is characterized), the 323 | Corresponding Source conveyed under this section must be accompanied 324 | by the Installation Information. But this requirement does not apply 325 | if neither you nor any third party retains the ability to install 326 | modified object code on the User Product (for example, the work has 327 | been installed in ROM). 328 | 329 | The requirement to provide Installation Information does not include a 330 | requirement to continue to provide support service, warranty, or updates 331 | for a work that has been modified or installed by the recipient, or for 332 | the User Product in which it has been modified or installed. Access to a 333 | network may be denied when the modification itself materially and 334 | adversely affects the operation of the network or violates the rules and 335 | protocols for communication across the network. 336 | 337 | Corresponding Source conveyed, and Installation Information provided, 338 | in accord with this section must be in a format that is publicly 339 | documented (and with an implementation available to the public in 340 | source code form), and must require no special password or key for 341 | unpacking, reading or copying. 342 | 343 | 7. Additional Terms. 344 | 345 | "Additional permissions" are terms that supplement the terms of this 346 | License by making exceptions from one or more of its conditions. 347 | Additional permissions that are applicable to the entire Program shall 348 | be treated as though they were included in this License, to the extent 349 | that they are valid under applicable law. If additional permissions 350 | apply only to part of the Program, that part may be used separately 351 | under those permissions, but the entire Program remains governed by 352 | this License without regard to the additional permissions. 353 | 354 | When you convey a copy of a covered work, you may at your option 355 | remove any additional permissions from that copy, or from any part of 356 | it. (Additional permissions may be written to require their own 357 | removal in certain cases when you modify the work.) You may place 358 | additional permissions on material, added by you to a covered work, 359 | for which you have or can give appropriate copyright permission. 360 | 361 | Notwithstanding any other provision of this License, for material you 362 | add to a covered work, you may (if authorized by the copyright holders of 363 | that material) supplement the terms of this License with terms: 364 | 365 | a) Disclaiming warranty or limiting liability differently from the 366 | terms of sections 15 and 16 of this License; or 367 | 368 | b) Requiring preservation of specified reasonable legal notices or 369 | author attributions in that material or in the Appropriate Legal 370 | Notices displayed by works containing it; or 371 | 372 | c) Prohibiting misrepresentation of the origin of that material, or 373 | requiring that modified versions of such material be marked in 374 | reasonable ways as different from the original version; or 375 | 376 | d) Limiting the use for publicity purposes of names of licensors or 377 | authors of the material; or 378 | 379 | e) Declining to grant rights under trademark law for use of some 380 | trade names, trademarks, or service marks; or 381 | 382 | f) Requiring indemnification of licensors and authors of that 383 | material by anyone who conveys the material (or modified versions of 384 | it) with contractual assumptions of liability to the recipient, for 385 | any liability that these contractual assumptions directly impose on 386 | those licensors and authors. 387 | 388 | All other non-permissive additional terms are considered "further 389 | restrictions" within the meaning of section 10. If the Program as you 390 | received it, or any part of it, contains a notice stating that it is 391 | governed by this License along with a term that is a further 392 | restriction, you may remove that term. If a license document contains 393 | a further restriction but permits relicensing or conveying under this 394 | License, you may add to a covered work material governed by the terms 395 | of that license document, provided that the further restriction does 396 | not survive such relicensing or conveying. 397 | 398 | If you add terms to a covered work in accord with this section, you 399 | must place, in the relevant source files, a statement of the 400 | additional terms that apply to those files, or a notice indicating 401 | where to find the applicable terms. 402 | 403 | Additional terms, permissive or non-permissive, may be stated in the 404 | form of a separately written license, or stated as exceptions; 405 | the above requirements apply either way. 406 | 407 | 8. Termination. 408 | 409 | You may not propagate or modify a covered work except as expressly 410 | provided under this License. Any attempt otherwise to propagate or 411 | modify it is void, and will automatically terminate your rights under 412 | this License (including any patent licenses granted under the third 413 | paragraph of section 11). 414 | 415 | However, if you cease all violation of this License, then your 416 | license from a particular copyright holder is reinstated (a) 417 | provisionally, unless and until the copyright holder explicitly and 418 | finally terminates your license, and (b) permanently, if the copyright 419 | holder fails to notify you of the violation by some reasonable means 420 | prior to 60 days after the cessation. 421 | 422 | Moreover, your license from a particular copyright holder is 423 | reinstated permanently if the copyright holder notifies you of the 424 | violation by some reasonable means, this is the first time you have 425 | received notice of violation of this License (for any work) from that 426 | copyright holder, and you cure the violation prior to 30 days after 427 | your receipt of the notice. 428 | 429 | Termination of your rights under this section does not terminate the 430 | licenses of parties who have received copies or rights from you under 431 | this License. If your rights have been terminated and not permanently 432 | reinstated, you do not qualify to receive new licenses for the same 433 | material under section 10. 434 | 435 | 9. Acceptance Not Required for Having Copies. 436 | 437 | You are not required to accept this License in order to receive or 438 | run a copy of the Program. Ancillary propagation of a covered work 439 | occurring solely as a consequence of using peer-to-peer transmission 440 | to receive a copy likewise does not require acceptance. However, 441 | nothing other than this License grants you permission to propagate or 442 | modify any covered work. These actions infringe copyright if you do 443 | not accept this License. Therefore, by modifying or propagating a 444 | covered work, you indicate your acceptance of this License to do so. 445 | 446 | 10. Automatic Licensing of Downstream Recipients. 447 | 448 | Each time you convey a covered work, the recipient automatically 449 | receives a license from the original licensors, to run, modify and 450 | propagate that work, subject to this License. You are not responsible 451 | for enforcing compliance by third parties with this License. 452 | 453 | An "entity transaction" is a transaction transferring control of an 454 | organization, or substantially all assets of one, or subdividing an 455 | organization, or merging organizations. If propagation of a covered 456 | work results from an entity transaction, each party to that 457 | transaction who receives a copy of the work also receives whatever 458 | licenses to the work the party's predecessor in interest had or could 459 | give under the previous paragraph, plus a right to possession of the 460 | Corresponding Source of the work from the predecessor in interest, if 461 | the predecessor has it or can get it with reasonable efforts. 462 | 463 | You may not impose any further restrictions on the exercise of the 464 | rights granted or affirmed under this License. For example, you may 465 | not impose a license fee, royalty, or other charge for exercise of 466 | rights granted under this License, and you may not initiate litigation 467 | (including a cross-claim or counterclaim in a lawsuit) alleging that 468 | any patent claim is infringed by making, using, selling, offering for 469 | sale, or importing the Program or any portion of it. 470 | 471 | 11. Patents. 472 | 473 | A "contributor" is a copyright holder who authorizes use under this 474 | License of the Program or a work on which the Program is based. The 475 | work thus licensed is called the contributor's "contributor version". 476 | 477 | A contributor's "essential patent claims" are all patent claims 478 | owned or controlled by the contributor, whether already acquired or 479 | hereafter acquired, that would be infringed by some manner, permitted 480 | by this License, of making, using, or selling its contributor version, 481 | but do not include claims that would be infringed only as a 482 | consequence of further modification of the contributor version. For 483 | purposes of this definition, "control" includes the right to grant 484 | patent sublicenses in a manner consistent with the requirements of 485 | this License. 486 | 487 | Each contributor grants you a non-exclusive, worldwide, royalty-free 488 | patent license under the contributor's essential patent claims, to 489 | make, use, sell, offer for sale, import and otherwise run, modify and 490 | propagate the contents of its contributor version. 491 | 492 | In the following three paragraphs, a "patent license" is any express 493 | agreement or commitment, however denominated, not to enforce a patent 494 | (such as an express permission to practice a patent or covenant not to 495 | sue for patent infringement). To "grant" such a patent license to a 496 | party means to make such an agreement or commitment not to enforce a 497 | patent against the party. 498 | 499 | If you convey a covered work, knowingly relying on a patent license, 500 | and the Corresponding Source of the work is not available for anyone 501 | to copy, free of charge and under the terms of this License, through a 502 | publicly available network server or other readily accessible means, 503 | then you must either (1) cause the Corresponding Source to be so 504 | available, or (2) arrange to deprive yourself of the benefit of the 505 | patent license for this particular work, or (3) arrange, in a manner 506 | consistent with the requirements of this License, to extend the patent 507 | license to downstream recipients. "Knowingly relying" means you have 508 | actual knowledge that, but for the patent license, your conveying the 509 | covered work in a country, or your recipient's use of the covered work 510 | in a country, would infringe one or more identifiable patents in that 511 | country that you have reason to believe are valid. 512 | 513 | If, pursuant to or in connection with a single transaction or 514 | arrangement, you convey, or propagate by procuring conveyance of, a 515 | covered work, and grant a patent license to some of the parties 516 | receiving the covered work authorizing them to use, propagate, modify 517 | or convey a specific copy of the covered work, then the patent license 518 | you grant is automatically extended to all recipients of the covered 519 | work and works based on it. 520 | 521 | A patent license is "discriminatory" if it does not include within 522 | the scope of its coverage, prohibits the exercise of, or is 523 | conditioned on the non-exercise of one or more of the rights that are 524 | specifically granted under this License. You may not convey a covered 525 | work if you are a party to an arrangement with a third party that is 526 | in the business of distributing software, under which you make payment 527 | to the third party based on the extent of your activity of conveying 528 | the work, and under which the third party grants, to any of the 529 | parties who would receive the covered work from you, a discriminatory 530 | patent license (a) in connection with copies of the covered work 531 | conveyed by you (or copies made from those copies), or (b) primarily 532 | for and in connection with specific products or compilations that 533 | contain the covered work, unless you entered into that arrangement, 534 | or that patent license was granted, prior to 28 March 2007. 535 | 536 | Nothing in this License shall be construed as excluding or limiting 537 | any implied license or other defenses to infringement that may 538 | otherwise be available to you under applicable patent law. 539 | 540 | 12. No Surrender of Others' Freedom. 541 | 542 | If conditions are imposed on you (whether by court order, agreement or 543 | otherwise) that contradict the conditions of this License, they do not 544 | excuse you from the conditions of this License. If you cannot convey a 545 | covered work so as to satisfy simultaneously your obligations under this 546 | License and any other pertinent obligations, then as a consequence you may 547 | not convey it at all. For example, if you agree to terms that obligate you 548 | to collect a royalty for further conveying from those to whom you convey 549 | the Program, the only way you could satisfy both those terms and this 550 | License would be to refrain entirely from conveying the Program. 551 | 552 | 13. Use with the GNU Affero General Public License. 553 | 554 | Notwithstanding any other provision of this License, you have 555 | permission to link or combine any covered work with a work licensed 556 | under version 3 of the GNU Affero General Public License into a single 557 | combined work, and to convey the resulting work. The terms of this 558 | License will continue to apply to the part which is the covered work, 559 | but the special requirements of the GNU Affero General Public License, 560 | section 13, concerning interaction through a network will apply to the 561 | combination as such. 562 | 563 | 14. Revised Versions of this License. 564 | 565 | The Free Software Foundation may publish revised and/or new versions of 566 | the GNU General Public License from time to time. Such new versions will 567 | be similar in spirit to the present version, but may differ in detail to 568 | address new problems or concerns. 569 | 570 | Each version is given a distinguishing version number. If the 571 | Program specifies that a certain numbered version of the GNU General 572 | Public License "or any later version" applies to it, you have the 573 | option of following the terms and conditions either of that numbered 574 | version or of any later version published by the Free Software 575 | Foundation. If the Program does not specify a version number of the 576 | GNU General Public License, you may choose any version ever published 577 | by the Free Software Foundation. 578 | 579 | If the Program specifies that a proxy can decide which future 580 | versions of the GNU General Public License can be used, that proxy's 581 | public statement of acceptance of a version permanently authorizes you 582 | to choose that version for the Program. 583 | 584 | Later license versions may give you additional or different 585 | permissions. However, no additional obligations are imposed on any 586 | author or copyright holder as a result of your choosing to follow a 587 | later version. 588 | 589 | 15. Disclaimer of Warranty. 590 | 591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY 592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT 593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY 594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM 597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF 598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 599 | 600 | 16. Limitation of Liability. 601 | 602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY 605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF 607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD 608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 610 | SUCH DAMAGES. 611 | 612 | 17. Interpretation of Sections 15 and 16. 613 | 614 | If the disclaimer of warranty and limitation of liability provided 615 | above cannot be given local legal effect according to their terms, 616 | reviewing courts shall apply local law that most closely approximates 617 | an absolute waiver of all civil liability in connection with the 618 | Program, unless a warranty or assumption of liability accompanies a 619 | copy of the Program in return for a fee. 620 | 621 | END OF TERMS AND CONDITIONS 622 | 623 | How to Apply These Terms to Your New Programs 624 | 625 | If you develop a new program, and you want it to be of the greatest 626 | possible use to the public, the best way to achieve this is to make it 627 | free software which everyone can redistribute and change under these terms. 628 | 629 | To do so, attach the following notices to the program. It is safest 630 | to attach them to the start of each source file to most effectively 631 | state the exclusion of warranty; and each file should have at least 632 | the "copyright" line and a pointer to where the full notice is found. 633 | 634 | 635 | Copyright (C) 636 | 637 | This program is free software: you can redistribute it and/or modify 638 | it under the terms of the GNU General Public License as published by 639 | the Free Software Foundation, either version 3 of the License, or 640 | (at your option) any later version. 641 | 642 | This program is distributed in the hope that it will be useful, 643 | but WITHOUT ANY WARRANTY; without even the implied warranty of 644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 645 | GNU General Public License for more details. 646 | 647 | You should have received a copy of the GNU General Public License 648 | along with this program. If not, see . 649 | 650 | Also add information on how to contact you by electronic and paper mail. 651 | 652 | If the program does terminal interaction, make it output a short 653 | notice like this when it starts in an interactive mode: 654 | 655 | Copyright (C) 656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. 657 | This is free software, and you are welcome to redistribute it 658 | under certain conditions; type `show c' for details. 659 | 660 | The hypothetical commands `show w' and `show c' should show the appropriate 661 | parts of the General Public License. Of course, your program's commands 662 | might be different; for a GUI interface, you would use an "about box". 663 | 664 | You should also get your employer (if you work as a programmer) or school, 665 | if any, to sign a "copyright disclaimer" for the program, if necessary. 666 | For more information on this, and how to apply and follow the GNU GPL, see 667 | . 668 | 669 | The GNU General Public License does not permit incorporating your program 670 | into proprietary programs. If your program is a subroutine library, you 671 | may consider it more useful to permit linking proprietary applications with 672 | the library. If this is what you want to do, use the GNU Lesser General 673 | Public License instead of this License. But first, please read 674 | . 675 | -------------------------------------------------------------------------------- /Messages.sh: -------------------------------------------------------------------------------- 1 | #! /usr/bin/env bash 2 | $XGETTEXT src/*.cpp -o $podir/plasma_runner_org.kde.firefoxprofilerunner.pot 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Firefox Profile Runner 2 | This plugin allows you to launch Firefox profiles from Krunner and your normal launcher. 3 | It saves the Desktop Actions for the profiles in a local copy of the firefox.desktop file. 4 | This means you can search for the profiles in your normal launcher. 5 | 6 | - Saves the Desktop Actions for the profiles in a local copy of the `firefox.desktop` file. This means you can search for the profiles in your normal launcher. 7 | - Compatible with Firefox-ESR. 8 | 9 | # Installation 10 | 11 | ## 1 Dependencies 12 | 13 | 14 |
15 | Debian/Ubuntu 16 | 17 | Plasma5: 18 | ```bash install-ubuntu-plasma5 19 | sudo apt install git cmake extra-cmake-modules build-essential libkf5runner-dev libkf5i18n-dev libkf5service-dev libkf5kcmutils-dev libkf5dbusaddons-bin 20 | ``` 21 | Plasma6: 22 | ```bash install-ubuntu-plasma6 23 | sudo apt install git cmake extra-cmake-modules build-essential libkf6runner-dev libkf6i18n-dev libkf6service-dev libkf6kcmutils-dev libkf6dbusaddons-bin 24 | ``` 25 | 26 |
27 | 28 |
29 | OpenSUSE 30 | 31 | Plasma5: 32 | ```bash install-opensuse-plasma5 33 | sudo zypper install git cmake extra-cmake-modules ki18n-devel krunner-devel kcmutils-devel kservice-devel kdbusaddons-tools libQt5Test-devel 34 | ``` 35 | Plasma6: 36 | ```bash install-opensuse-plasma6 37 | sudo zypper install git cmake kf6-extra-cmake-modules kf6-ki18n-devel kf6-krunner-devel kf6-kcmutils-devel kf6-kservice-devel kf6-kdbusaddons-tools qt6-test-devel 38 | ``` 39 | 40 |
41 | 42 |
43 | Fedora 44 | 45 | Plasma5: 46 | ```bash install-fedora-plasma5 47 | sudo dnf install git cmake extra-cmake-modules kf5-ki18n-devel kf5-krunner-devel kf5-kcmutils-devel kf5-kservice-devel 48 | ``` 49 | Plasma6: 50 | ```bash install-fedora-plasma6 51 | sudo dnf install git cmake extra-cmake-modules kf6-ki18n-devel kf6-krunner-devel kf6-kcmutils-devel kf6-kservice-devel 52 | ``` 53 | 54 |
55 | 56 | ## 2 Plugin 57 | 58 | ### A: Oneliner install 59 | 60 | ```shell 61 | curl https://raw.githubusercontent.com/alex1701c/krunner-firefox/master/install.sh | bash 62 | ``` 63 | 64 | ### B: Oneliner install (Without admin privileges) 65 | 66 | ```shell 67 | curl https://raw.githubusercontent.com/alex1701c/krunner-firefox/master/install-user.sh | bash 68 | ``` 69 | 70 | # Screenshots 71 | 72 | #### Overview 73 | The plugin gets triggered by `firef`. 74 | 75 | ![Overview](https://raw.githubusercontent.com/alex1701c/Screenshots/master/FirefoxProfileRunner/runner_profiles_overview.png) 76 | 77 | #### Search 78 | After the trigger word, you can search the profiles. 79 | 80 | ![Search](https://raw.githubusercontent.com/alex1701c/Screenshots/master/FirefoxProfileRunner/runner_profiles_search.png) 81 | 82 | #### Config Dialog 83 | If you uncheck the options to register the normal/private window launch options profiles globally you can not launch 84 | the profiles like in the last screenshot. 85 | If the following option is checked the option to launch a normal window with the default profile is not shown. 86 | This is useful, because the default profile can be launched with the "Applications" plugin. 87 | The option to always show private windows is demonstrated in the first screenshot. 88 | 89 | Using the Move Up/Down buttons you can change the order of the options. 90 | The text field below is used to rename the profiles. This does not modify the Firefox 91 | configuration, just the displayed name for the runner. 92 | 93 | ![Config Dialog](https://raw.githubusercontent.com/alex1701c/Screenshots/master/FirefoxProfileRunner/general_config_dialog.png) 94 | 95 | #### Overview With All Global Options 96 | After the trigger word, you can search the profiles. 97 | 98 | ![Overview With All Global Options](https://raw.githubusercontent.com/alex1701c/Screenshots/master/FirefoxProfileRunner/global_overview_proxychains.png) 99 | -------------------------------------------------------------------------------- /install.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | # Exit immediately if something fails 4 | set -e 5 | 6 | # Clone project if it is downloaded using curl 7 | if [[ $(basename "$PWD") != "krunner-firefox"* ]]; then 8 | git clone https://github.com/alex1701c/krunner-firefox 9 | cd krunner-firefox/ 10 | fi 11 | 12 | mkdir -p build 13 | cd build 14 | krunner_version=$(krunner --version | grep -oP "(?<=krunner )\d+") 15 | if [[ "$krunner_version" == "6" ]]; then 16 | echo "Building for Plasma6" 17 | BUILD_QT6_OPTION="-DBUILD_WITH_QT6=ON" 18 | else 19 | echo "Building for Plasma5" 20 | BUILD_QT6_OPTION="" 21 | fi 22 | 23 | cmake .. -DCMAKE_BUILD_TYPE=Release -DKDE_INSTALL_USE_QT_SYS_PATHS=ON -DBUILD_TESTING=OFF $BUILD_QT6_OPTION 24 | make -j$(nproc) 25 | sudo make install/fast 26 | 27 | # KRunner needs to be restarted for the changes to be applied 28 | if pgrep -x krunner > /dev/null 29 | then 30 | kquitapp$krunner_version krunner 31 | fi 32 | 33 | echo "Installation finished!"; 34 | -------------------------------------------------------------------------------- /postinst: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if pgrep -x krunner > /dev/null 4 | then 5 | killall krunner 6 | fi 7 | -------------------------------------------------------------------------------- /postrm: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if pgrep -x krunner > /dev/null 4 | then 5 | killall krunner 6 | fi 7 | -------------------------------------------------------------------------------- /src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_definitions(-DTRANSLATION_DOMAIN=\"plasma_runner_org.kde.firefoxprofilerunner\") 2 | 3 | add_library(core_STATIC STATIC profile/Profile.cpp profile/ProfileManager.cpp) 4 | target_link_libraries(core_STATIC PUBLIC KF${QT_MAJOR_VERSION}::ConfigCore KF${QT_MAJOR_VERSION}::Service) 5 | set_target_properties(core_STATIC PROPERTIES POSITION_INDEPENDENT_CODE ON) 6 | ecm_qt_declare_logging_category(core_STATIC 7 | HEADER firefox_debug.h 8 | IDENTIFIER FIREFOX 9 | CATEGORY_NAME ${PROJECT_NAME} 10 | DESCRIPTION "Logging for ${PROJECT_NAME}" 11 | EXPORT FIREFOX 12 | ) 13 | ecm_qt_install_logging_categories( 14 | EXPORT FIREFOX 15 | FILE krunner_firefox.categories 16 | DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR} 17 | ) 18 | 19 | 20 | configure_file(firefoxprofilerunner.json.in firefoxprofilerunner.json) 21 | kcoreaddons_add_plugin(firefoxprofilerunner SOURCES firefoxprofilerunner.cpp INSTALL_NAMESPACE "kf${QT_MAJOR_VERSION}/krunner") 22 | target_link_libraries(firefoxprofilerunner 23 | Qt::Core 24 | Qt::Widgets 25 | KF${QT_MAJOR_VERSION}::Runner 26 | KF${QT_MAJOR_VERSION}::I18n 27 | KF${QT_MAJOR_VERSION}::Service 28 | core_STATIC 29 | ) 30 | 31 | set(kcm_firefoxprofilerunner_SRCS ${core_SRCS} config/firefoxprofilerunner_config.cpp) 32 | kcoreaddons_add_plugin(kcm_firefoxprofilerunner SOURCES ${kcm_firefoxprofilerunner_SRCS} INSTALL_NAMESPACE "krunner/kcms") 33 | ki18n_wrap_ui(kcm_firefoxprofilerunner config/firefoxprofilerunner_config.ui) 34 | target_link_libraries(kcm_firefoxprofilerunner 35 | Qt::Core 36 | Qt::Gui 37 | KF${QT_MAJOR_VERSION}::CoreAddons 38 | KF${QT_MAJOR_VERSION}::ConfigCore 39 | KF${QT_MAJOR_VERSION}::I18n 40 | KF${QT_MAJOR_VERSION}::KCMUtils 41 | KF${QT_MAJOR_VERSION}::Runner 42 | core_STATIC 43 | ) 44 | 45 | install(FILES private_browsing_firefox.svg DESTINATION ${KDE_INSTALL_DATADIR}/pixmaps/) 46 | -------------------------------------------------------------------------------- /src/Config.h: -------------------------------------------------------------------------------- 1 | #ifndef FIREFOXPROFILERUNNER_CONFIG_H 2 | #define FIREFOXPROFILERUNNER_CONFIG_H 3 | 4 | #include 5 | #include 6 | 7 | namespace 8 | { 9 | class Config 10 | { 11 | public: 12 | // General settings 13 | constexpr static const auto MainGroup = "Config"; 14 | constexpr static const auto HideDefaultProfile = "hideDefaultProfile"; 15 | constexpr static const auto ShowAlwaysPrivateWindows = "showAlwaysPrivateWindows"; 16 | 17 | // Profile settings 18 | constexpr static const auto RegisterNormalWindows = "registerNormalWindows"; 19 | constexpr static const auto RegisterPrivateWindows = "registerPrivateWindows"; 20 | constexpr static const auto PrivateWindowAction = "privateWindowActions"; 21 | // UI settings 22 | constexpr static const auto GeneralMinimized = "generalMinimized"; 23 | 24 | static QString getPrivateWindowIcon() 25 | { 26 | if (const QString path = "/usr/share/pixmaps/private_browsing_firefox.svg"; QFileInfo::exists(path)) { 27 | return path; 28 | } 29 | return "view-private"; 30 | } 31 | }; 32 | } 33 | 34 | #endif // FIREFOXPROFILERUNNER_CONFIG_H 35 | -------------------------------------------------------------------------------- /src/config/config_types.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | enum ProfileType { 7 | Normal, 8 | Private, 9 | }; 10 | 11 | struct ProfileData { 12 | QString path; 13 | bool isDefault; 14 | ProfileType type; 15 | int priority; 16 | }; 17 | Q_DECLARE_METATYPE(ProfileData) 18 | -------------------------------------------------------------------------------- /src/config/firefoxprofilerunner_config.cpp: -------------------------------------------------------------------------------- 1 | #include "firefoxprofilerunner_config.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #include "config_types.h" 11 | 12 | K_PLUGIN_CLASS(FirefoxRunnerConfig) 13 | 14 | inline ProfileData widgetData(const QListWidgetItem *item) 15 | { 16 | const QVariant &var = item->data(Qt::UserRole); 17 | return var.value(); 18 | } 19 | 20 | FirefoxProfileRunnerConfigForm::FirefoxProfileRunnerConfigForm(QWidget *parent) 21 | : QWidget(parent) 22 | { 23 | setupUi(this); 24 | } 25 | 26 | FirefoxRunnerConfig::FirefoxRunnerConfig(QObject *parent, const QVariantList &) 27 | : KCModule(parent) 28 | { 29 | m_ui = new FirefoxProfileRunnerConfigForm(widget()); 30 | auto *layout = new QGridLayout(widget()); 31 | layout->addWidget(m_ui, 0, 0); 32 | 33 | connectSignals(); 34 | 35 | firefoxConfig = KSharedConfig::openConfig(profileManager.firefoxDesktopFile); 36 | config = KSharedConfig::openConfig("krunnerrc")->group("Runners").group("firefoxprofilerunner"); 37 | config.config()->reparseConfiguration(); 38 | firefoxIcon = QIcon::fromTheme(profileManager.launchCommand.endsWith("firefox") ? "firefox" : "firefox-esr"); 39 | } 40 | 41 | void FirefoxRunnerConfig::load() 42 | { 43 | m_ui->registerPrivateWindows->setChecked(config.readEntry(Config::RegisterPrivateWindows, true)); 44 | m_ui->registerNormalWindows->setChecked(config.readEntry(Config::RegisterNormalWindows, true)); 45 | m_ui->hideDefaultProfile->setChecked(config.readEntry(Config::HideDefaultProfile, false)); 46 | m_ui->showAlwaysPrivateWindows->setChecked(config.readEntry(Config::ShowAlwaysPrivateWindows, true)); 47 | m_ui->privateWindowAction->setChecked(config.readEntry(Config::PrivateWindowAction, false)); 48 | privateWindowsAsActionsChanged(); 49 | 50 | profileManager = ProfileManager(); 51 | profiles = profileManager.syncAndGetCustomProfiles(config, forceProfileSync); 52 | forceProfileSync = false; 53 | m_ui->profiles->clear(); 54 | 55 | const QIcon privateWindowIcon = QIcon::fromTheme(Config::getPrivateWindowIcon()); 56 | QList items; 57 | for (int i = 0; i < profiles.count(); ++i) { 58 | auto &profile = profiles.at(i); 59 | // Normal window 60 | auto *item = new QListWidgetItem(); 61 | item->setText(profile.name); 62 | auto data = QVariant::fromValue(ProfileData{profile.path, profile.isDefault, ProfileType::Normal, profile.priority}); 63 | item->setData(Qt::UserRole, data); 64 | item->setIcon(firefoxIcon); 65 | items.append(item); 66 | // Private window 67 | auto *item2 = new QListWidgetItem(); 68 | item2->setText(profile.name); 69 | auto data2 = QVariant::fromValue(ProfileData{profile.path, profile.isDefault, ProfileType::Private, profile.privateWindowPriority}); 70 | item2->setData(Qt::UserRole, data2); 71 | item2->setIcon(privateWindowIcon); 72 | items.append(item2); 73 | } 74 | std::sort(items.begin(), items.end(), [](const QListWidgetItem *item1, const QListWidgetItem *item2) -> bool { 75 | return widgetData(item1).priority > widgetData(item2).priority; 76 | }); 77 | for (const auto &item : qAsConst(items)) { 78 | m_ui->profiles->addItem(item); 79 | } 80 | 81 | // Initial validation 82 | showAlwaysPrivateWindows(); 83 | if (config.readEntry(Config::GeneralMinimized, false)) { 84 | toggleGeneralConfigVisibility(); 85 | } 86 | 87 | hideDefaultProfile(); 88 | } 89 | 90 | void FirefoxRunnerConfig::save() 91 | { 92 | // Write general settings 93 | config.writeEntry(Config::GeneralMinimized, m_ui->firefoxGeneralConfigWidget->isHidden()); 94 | config.writeEntry(Config::RegisterNormalWindows, m_ui->registerNormalWindows->isChecked()); 95 | config.writeEntry(Config::RegisterPrivateWindows, m_ui->registerPrivateWindows->isChecked()); 96 | config.writeEntry(Config::PrivateWindowAction, m_ui->privateWindowAction->isChecked()); 97 | config.writeEntry(Config::HideDefaultProfile, m_ui->hideDefaultProfile->isEnabled() && m_ui->hideDefaultProfile->isChecked()); 98 | config.writeEntry(Config::ShowAlwaysPrivateWindows, m_ui->showAlwaysPrivateWindows->isEnabled() && m_ui->showAlwaysPrivateWindows->isChecked()); 99 | 100 | // Organize entries in a map > 101 | QMap> organizedItems; 102 | for (int i = 0; i < m_ui->profiles->count(); ++i) { 103 | auto *item = m_ui->profiles->item(i); 104 | auto data = widgetData(item); 105 | data.priority = 100 - i; 106 | item->setData(Qt::UserRole, QVariant::fromValue(data)); 107 | auto newData = organizedItems.value(data.path); 108 | newData.insert(data.type, item); 109 | organizedItems.insert(data.path, newData); 110 | } 111 | // Sync profiles with entries from map 112 | for (auto &profile : profiles) { 113 | // Reset optional values to false/0 114 | profile.privateWindowPriority = 0; 115 | 116 | auto itemMap = organizedItems.value(profile.path); 117 | for (const auto &type : itemMap.keys()) { 118 | const auto item = itemMap.value(type); 119 | const auto itemData = widgetData(item); 120 | if (type == Normal) { 121 | profile.name = item->text(); 122 | profile.priority = itemData.priority; 123 | } else if (type == Private) { 124 | profile.privateWindowPriority = itemData.priority; 125 | } 126 | } 127 | profile.writeConfigChanges(firefoxConfig); 128 | } 129 | 130 | // Change registering based on new settings 131 | profileManager.changeProfileRegistering(m_ui->registerNormalWindows->isChecked(), m_ui->registerPrivateWindows->isChecked(), firefoxConfig); 132 | // New runner instance has latest configuration 133 | QProcess::startDetached("bash", 134 | QStringList() << "-c" 135 | << "kquitapp5 krunner;kstart5 krunner > /dev/null"); 136 | } 137 | 138 | void FirefoxRunnerConfig::defaults() 139 | { 140 | m_ui->registerNormalWindows->setChecked(true); 141 | m_ui->registerPrivateWindows->setChecked(true); 142 | m_ui->hideDefaultProfile->setChecked(false); 143 | m_ui->showAlwaysPrivateWindows->setChecked(true); 144 | m_ui->privateWindowAction->setChecked(false); 145 | privateWindowsAsActionsChanged(); 146 | 147 | hideDefaultProfile(); 148 | 149 | markAsChanged(); 150 | } 151 | 152 | void FirefoxRunnerConfig::connectSignals() 153 | { 154 | const auto changedSlotPointer = &FirefoxRunnerConfig::markAsChanged; 155 | const auto toggleConfigPointer = static_cast(&FirefoxRunnerConfig::toggleGeneralConfigVisibility); 156 | 157 | // General settings 158 | connect(m_ui->registerNormalWindows, &QCheckBox::clicked, this, changedSlotPointer); 159 | connect(m_ui->registerPrivateWindows, &QCheckBox::clicked, this, changedSlotPointer); 160 | connect(m_ui->hideDefaultProfile, &QCheckBox::clicked, this, changedSlotPointer); 161 | connect(m_ui->hideDefaultProfile, &QCheckBox::clicked, this, &FirefoxRunnerConfig::hideDefaultProfile); 162 | connect(m_ui->hideDefaultProfile, &QCheckBox::clicked, this, &FirefoxRunnerConfig::itemSelected); 163 | connect(m_ui->showAlwaysPrivateWindows, &QCheckBox::clicked, this, changedSlotPointer); 164 | connect(m_ui->showAlwaysPrivateWindows, &QCheckBox::clicked, this, &FirefoxRunnerConfig::showAlwaysPrivateWindows); 165 | connect(m_ui->showAlwaysPrivateWindows, &QCheckBox::clicked, this, &FirefoxRunnerConfig::itemSelected); 166 | connect(m_ui->privateWindowAction, &QCheckBox::clicked, this, changedSlotPointer); 167 | connect(m_ui->privateWindowAction, &QCheckBox::clicked, this, &FirefoxRunnerConfig::privateWindowsAsActionsChanged); 168 | 169 | // Different item gets selected 170 | connect(m_ui->profiles, &QListWidget::itemSelectionChanged, this, &FirefoxRunnerConfig::itemSelected); 171 | connect(m_ui->profiles, &QListWidget::itemSelectionChanged, this, &FirefoxRunnerConfig::editProfileName); 172 | // Order gets changes 173 | connect(m_ui->moveUp, &QPushButton::clicked, this, &FirefoxRunnerConfig::moveUp); 174 | connect(m_ui->moveDown, &QPushButton::clicked, this, &FirefoxRunnerConfig::moveDown); 175 | connect(m_ui->moveUp, &QPushButton::clicked, this, changedSlotPointer); 176 | connect(m_ui->moveDown, &QPushButton::clicked, this, changedSlotPointer); 177 | // Edit profile name 178 | connect(m_ui->editProfileName, &QLineEdit::textChanged, this, &FirefoxRunnerConfig::editProfileName); 179 | connect(m_ui->editProfileNameApply, &QPushButton::clicked, this, &FirefoxRunnerConfig::applyProfileName); 180 | connect(m_ui->editProfileNameApply, &QPushButton::clicked, this, changedSlotPointer); 181 | connect(m_ui->editProfileNameCancel, &QPushButton::clicked, this, &FirefoxRunnerConfig::cancelProfileName); 182 | // Refresh profiles button 183 | connect(m_ui->refreshProfiles, &QPushButton::clicked, this, &FirefoxRunnerConfig::refreshProfiles); 184 | connect(m_ui->refreshProfiles, &QPushButton::clicked, this, changedSlotPointer); 185 | // Hide/unhide buttons 186 | connect(m_ui->generalConfigToggleHidePushButton, &QPushButton::clicked, this, toggleConfigPointer); 187 | connect(m_ui->generalConfigToggleHidePushButton, &QPushButton::clicked, this, changedSlotPointer); 188 | } 189 | 190 | /** 191 | * Enable/Disable Up/Down buttons 192 | */ 193 | void FirefoxRunnerConfig::itemSelected() 194 | { 195 | const int idx = m_ui->profiles->currentRow(); 196 | // When the checkboxes are clicked but no item has been selected 197 | if (idx == -1) { 198 | return; 199 | } 200 | const int count = m_ui->profiles->count(); 201 | 202 | // Check if there is any hidden option below/above current item 203 | bool upDisabled = true; 204 | bool downDisabled = true; 205 | for (int i = 0; i < count; i++) { 206 | if (!m_ui->profiles->item(i)->isHidden() && i < idx) { 207 | upDisabled = false; 208 | break; 209 | } 210 | } 211 | for (int i = count - 1; i >= 0; i--) { 212 | if (!m_ui->profiles->item(i)->isHidden() && i > idx) { 213 | downDisabled = false; 214 | break; 215 | } 216 | } 217 | m_ui->moveUp->setDisabled(upDisabled); 218 | m_ui->moveDown->setDisabled(downDisabled); 219 | m_ui->editProfileName->setText(m_ui->profiles->currentItem()->text()); 220 | m_ui->editProfileName->setDisabled(false); 221 | } 222 | 223 | /** 224 | * Refresh profiles from profiles.ini file, all unsaved changes are discarded 225 | */ 226 | void FirefoxRunnerConfig::refreshProfiles() 227 | { 228 | if (!edited) { 229 | forceProfileSync = true; 230 | load(); 231 | } else { 232 | QMessageBox::StandardButton reply = // 233 | QMessageBox::question(widget(), 234 | "Discard changes?", 235 | "Do you want to refresh the current config and discard all unsaved changes", 236 | QMessageBox::Yes | QMessageBox::No); 237 | if (reply == QMessageBox::Yes) { 238 | forceProfileSync = true; 239 | load(); 240 | } else { 241 | return; 242 | } 243 | } 244 | // Disable Buttons like on initial state 245 | m_ui->profiles->setFocus(); 246 | if (m_ui->profiles->count() > 0) { 247 | m_ui->profiles->setCurrentRow(0); 248 | } 249 | edited = false; 250 | hideDefaultProfile(); 251 | } 252 | 253 | void FirefoxRunnerConfig::privateWindowsAsActionsChanged() 254 | { 255 | m_ui->hideDefaultProfile->setDisabled(m_ui->privateWindowAction->isChecked()); 256 | m_ui->showAlwaysPrivateWindows->setDisabled(m_ui->privateWindowAction->isChecked()); 257 | showAlwaysPrivateWindows(); 258 | hideDefaultProfile(); 259 | } 260 | 261 | /** 262 | * Move item up 263 | */ 264 | void FirefoxRunnerConfig::moveUp() 265 | { 266 | edited = true; 267 | const int current = m_ui->profiles->currentRow(); 268 | if (current < 1) { 269 | return; 270 | } 271 | 272 | // Insert element at index of first visible element above 273 | int newIdx = current; 274 | for (int i = current - 1; i >= 0; --i) { 275 | if (!m_ui->profiles->item(i)->isHidden()) { 276 | newIdx = i; 277 | break; 278 | } 279 | } 280 | const auto item = m_ui->profiles->takeItem(current); 281 | m_ui->profiles->insertItem(newIdx, item); 282 | m_ui->profiles->setCurrentRow(newIdx); 283 | } 284 | 285 | /** 286 | * Move item down 287 | */ 288 | void FirefoxRunnerConfig::moveDown() 289 | { 290 | edited = true; 291 | const int current = m_ui->profiles->currentRow(); 292 | const int count = m_ui->profiles->count(); 293 | if (current == -1) { 294 | return; 295 | } 296 | 297 | // Insert element at index of first visible element above 298 | int newIdx = current; 299 | for (int i = current + 1; i < count; ++i) { 300 | if (!m_ui->profiles->item(i)->isHidden()) { 301 | newIdx = i; 302 | break; 303 | } 304 | } 305 | const auto item = m_ui->profiles->takeItem(current); 306 | m_ui->profiles->insertItem(newIdx, item); 307 | m_ui->profiles->setCurrentRow(newIdx); 308 | } 309 | 310 | /** 311 | * Update name of profile 312 | */ 313 | void FirefoxRunnerConfig::applyProfileName() 314 | { 315 | edited = true; 316 | const QString editedText = m_ui->editProfileName->text(); 317 | if (m_ui->profiles->currentRow() == -1) { 318 | return; 319 | } 320 | const QString textBeforeEditing = m_ui->profiles->currentItem()->text(); 321 | const int count = m_ui->profiles->count(); 322 | 323 | m_ui->profiles->currentItem()->setText(editedText); 324 | for (int i = 0; i < count; ++i) { 325 | auto *item = m_ui->profiles->item(i); 326 | if (item->text() == textBeforeEditing) { 327 | item->setText(editedText); 328 | break; 329 | } 330 | } 331 | 332 | m_ui->editProfileNameApply->setDisabled(true); 333 | m_ui->editProfileNameCancel->setDisabled(true); 334 | m_ui->profiles->setFocus(); 335 | } 336 | 337 | /** 338 | * Reset text of name edit field to initial name 339 | */ 340 | void FirefoxRunnerConfig::cancelProfileName() 341 | { 342 | if (m_ui->profiles->currentRow() != -1) { 343 | m_ui->editProfileName->setText(m_ui->profiles->currentItem()->text()); 344 | m_ui->editProfileName->setFocus(); 345 | } 346 | } 347 | 348 | /** 349 | * Validate buttons to cancel/apply the changes to profile name 350 | */ 351 | void FirefoxRunnerConfig::editProfileName() 352 | { 353 | if (m_ui->profiles->currentRow() != -1) { 354 | m_ui->editProfileNameApply->setDisabled(m_ui->profiles->currentItem()->text() == m_ui->editProfileName->text() 355 | || m_ui->editProfileName->text().isEmpty()); 356 | m_ui->editProfileNameCancel->setDisabled(m_ui->profiles->currentItem()->text() == m_ui->editProfileName->text()); 357 | } 358 | } 359 | 360 | /** 361 | * Hide hide/unhide all private window options 362 | */ 363 | void FirefoxRunnerConfig::showAlwaysPrivateWindows() 364 | { 365 | const bool hide = !m_ui->showAlwaysPrivateWindows->isChecked() || !m_ui->showAlwaysPrivateWindows->isEnabled(); 366 | for (int i = 0; i < m_ui->profiles->count(); ++i) { 367 | QListWidgetItem *item = m_ui->profiles->item(i); 368 | if (widgetData(item).type == ProfileType::Private) { 369 | item->setHidden(hide); 370 | } 371 | } 372 | } 373 | 374 | /** 375 | * Hide default profile from profiles list if checkbox is checked 376 | */ 377 | void FirefoxRunnerConfig::hideDefaultProfile() 378 | { 379 | const bool hide = m_ui->hideDefaultProfile->isChecked() && m_ui->hideDefaultProfile->isEnabled(); 380 | for (int i = 0; i < m_ui->profiles->count(); ++i) { 381 | QListWidgetItem *item = m_ui->profiles->item(i); 382 | const auto data = widgetData(item); 383 | if (data.type == ProfileType::Normal && data.isDefault) { 384 | item->setHidden(hide); 385 | break; 386 | } 387 | } 388 | } 389 | 390 | /** 391 | * Hide/Show the general config config widgets 392 | */ 393 | void FirefoxRunnerConfig::toggleGeneralConfigVisibility() 394 | { 395 | bool hide = !m_ui->firefoxGeneralConfigWidget->isHidden(); 396 | m_ui->generalConfigToggleHidePushButton->setIcon(hide ? downIcon : upIcon); 397 | m_ui->firefoxGeneralConfigWidget->setHidden(hide); 398 | } 399 | 400 | #include "firefoxprofilerunner_config.moc" 401 | #include "moc_firefoxprofilerunner_config.cpp" 402 | -------------------------------------------------------------------------------- /src/config/firefoxprofilerunner_config.h: -------------------------------------------------------------------------------- 1 | #ifndef FirefoxProfileRunnerCONFIG_H 2 | #define FirefoxProfileRunnerCONFIG_H 3 | 4 | #include 5 | 6 | #include "profile/ProfileManager.h" 7 | #include "ui_firefoxprofilerunner_config.h" 8 | #include 9 | #include 10 | #include 11 | 12 | class FirefoxProfileRunnerConfigForm : public QWidget, public Ui::FirefoxProfileRunnerConfigUi 13 | { 14 | Q_OBJECT 15 | 16 | public: 17 | explicit FirefoxProfileRunnerConfigForm(QWidget *parent); 18 | }; 19 | 20 | class FirefoxRunnerConfig : public KCModule 21 | { 22 | Q_OBJECT 23 | 24 | public: 25 | explicit FirefoxRunnerConfig(QObject *parent, const QVariantList &args); 26 | 27 | QIcon firefoxIcon; 28 | const QIcon firefoxPrivateWindowIcon = QIcon::fromTheme("private_browsing_firefox"); 29 | const QIcon upIcon = QIcon::fromTheme("arrow-up"); 30 | const QIcon downIcon = QIcon::fromTheme("arrow-down"); 31 | ProfileManager profileManager; 32 | QList profiles; 33 | KSharedConfigPtr firefoxConfig; 34 | KConfigGroup config; 35 | 36 | bool edited, forceProfileSync = false; 37 | 38 | public Q_SLOTS: 39 | void save() override; 40 | void load() override; 41 | void defaults() override; 42 | void connectSignals(); 43 | 44 | // General config slots 45 | void showAlwaysPrivateWindows(); 46 | void hideDefaultProfile(); 47 | void refreshProfiles(); 48 | void privateWindowsAsActionsChanged(); 49 | 50 | // Profile sorting/editing signals 51 | void itemSelected(); 52 | void moveUp(); 53 | void moveDown(); 54 | 55 | void applyProfileName(); 56 | void cancelProfileName(); 57 | void editProfileName(); 58 | void toggleGeneralConfigVisibility(); 59 | 60 | private: 61 | FirefoxProfileRunnerConfigForm *m_ui; 62 | }; 63 | 64 | #endif 65 | -------------------------------------------------------------------------------- /src/config/firefoxprofilerunner_config.ui: -------------------------------------------------------------------------------- 1 | 2 | 3 | %{AUTHOR} 4 | FirefoxProfileRunnerConfigUi 5 | 6 | 7 | 8 | 0 9 | 0 10 | 709 11 | 711 12 | 13 | 14 | 15 | 16 | 600 17 | 0 18 | 19 | 20 | 21 | 22 | 16777215 23 | 16777215 24 | 25 | 26 | 27 | Qt::NoFocus 28 | 29 | 30 | 31 | 32 | 33 | 34 | 600 35 | 0 36 | 37 | 38 | 39 | 40 | 16777215 41 | 16777215 42 | 43 | 44 | 45 | Qt::NoFocus 46 | 47 | 48 | true 49 | 50 | 51 | 52 | 53 | 0 54 | 0 55 | 697 56 | 699 57 | 58 | 59 | 60 | 61 | 16777215 62 | 16777214 63 | 64 | 65 | 66 | 67 | 68 | 69 | true 70 | 71 | 72 | 73 | 0 74 | 0 75 | 76 | 77 | 78 | Qt::LeftToRight 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 0 94 | 0 95 | 96 | 97 | 98 | General Config 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 0 107 | 0 108 | 109 | 110 | 111 | Hide/Unhide Section 112 | 113 | 114 | 115 | 116 | 117 | 118 | .. 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | Show options to launch profiles in normal windows globally 131 | 132 | 133 | 134 | 135 | 136 | 137 | Show options to launch profiles in private windows globally 138 | 139 | 140 | 141 | 142 | 143 | 144 | Hide option to open a normal window with default profile 145 | 146 | 147 | 148 | 149 | 150 | 151 | Always show option to open private windows (with plugin) 152 | 153 | 154 | 155 | 156 | 157 | 158 | Show option to open private window as action (with plugin) 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | Qt::Vertical 172 | 173 | 174 | QSizePolicy::Fixed 175 | 176 | 177 | 178 | 20 179 | 20 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 0 191 | 0 192 | 193 | 194 | 195 | 196 | 16777215 197 | 300 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | Qt::Vertical 210 | 211 | 212 | 213 | 20 214 | 40 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | false 223 | 224 | 225 | Move Up 226 | 227 | 228 | 229 | 230 | 231 | 232 | false 233 | 234 | 235 | Move Down 236 | 237 | 238 | 239 | 240 | 241 | 242 | Qt::Vertical 243 | 244 | 245 | 246 | 20 247 | 40 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | 263 | false 264 | 265 | 266 | 267 | 268 | 269 | 270 | false 271 | 272 | 273 | Apply 274 | 275 | 276 | 277 | 278 | 279 | 280 | false 281 | 282 | 283 | Reset 284 | 285 | 286 | 287 | 288 | 289 | 290 | 291 | 292 | Sync Firefox Profile Config 293 | 294 | 295 | 296 | 297 | 298 | 299 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | -------------------------------------------------------------------------------- /src/firefoxprofilerunner.cpp: -------------------------------------------------------------------------------- 1 | #include "firefoxprofilerunner.h" 2 | #include "Config.h" 3 | #include "profile/Profile.h" 4 | #include "profile/ProfileManager.h" 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | FirefoxRunner::FirefoxRunner(QObject *parent, const KPluginMetaData &data, const QVariantList &) 17 | #if KRUNNER_VERSION_MAJOR == 5 18 | : AbstractRunner(parent, data, QVariantList{}) 19 | , firefoxPrivateWindowIcon(Config::getPrivateWindowIcon()) 20 | , matchActions({new QAction(QIcon::fromTheme(firefoxPrivateWindowIcon), "Open profile in private window", this)}) 21 | #else 22 | : AbstractRunner(parent, data) 23 | , firefoxPrivateWindowIcon(Config::getPrivateWindowIcon()) 24 | , matchActions({KRunner::Action("private-window", firefoxPrivateWindowIcon, "Open profile in private window")}) 25 | #endif 26 | { 27 | } 28 | 29 | void FirefoxRunner::reloadConfiguration() 30 | { 31 | KConfigGroup grp = config(); 32 | ProfileManager profileManager; 33 | profiles = profileManager.syncAndGetCustomProfiles(grp); 34 | if (profiles.isEmpty()) { 35 | // If the profiles.ini file has not changes and there are no profiles 36 | // For instance if you rerun the install script 37 | profiles = profileManager.syncAndGetCustomProfiles(grp, true); 38 | } 39 | launchCommand = profileManager.launchCommand; 40 | firefoxIcon = profileManager.iconForExecutable(); 41 | 42 | hideDefaultProfile = grp.readEntry(Config::HideDefaultProfile, false); 43 | showAlwaysPrivateWindows = grp.readEntry(Config::ShowAlwaysPrivateWindows, true); 44 | 45 | privateWindowsAsActions = grp.readEntry(Config::PrivateWindowAction, false); 46 | 47 | QList syntaxes; 48 | syntaxes.append(RunnerSyntax("firefox :q:", "Plugin gets triggered by fire... after that you can search the profiles by name")); 49 | syntaxes.append(RunnerSyntax("firefox -p :q:", "Launch profile in private window")); 50 | syntaxes.append(RunnerSyntax("firefox :q: -p", "Launch profile in private window")); 51 | syntaxes.append(RunnerSyntax("ff :q:", "Plugin gets triggered by ff... after that you can search the profiles by name")); 52 | syntaxes.append(RunnerSyntax("ff -p :q:", "Launch profile in private window")); 53 | syntaxes.append(RunnerSyntax("ff :q: -p", "Launch profile in private window")); 54 | setSyntaxes(syntaxes); 55 | } 56 | 57 | void FirefoxRunner::match(RunnerContext &context) 58 | { 59 | KSycoca::disableAutoRebuild(); 60 | QString term = context.query(); 61 | if (!context.isValid()) { 62 | return; 63 | } 64 | if (!term.startsWith(shortPrefix, Qt::CaseInsensitive) && !term.startsWith(mediumPrefix, Qt::CaseInsensitive)) { 65 | return; 66 | } 67 | 68 | QList matches; 69 | bool privateWindow = false; 70 | if (!privateWindowsAsActions && term.contains(privateWindowFlagRegex)) { 71 | privateWindow = true; 72 | term.remove(privateWindowFlagRegex); 73 | } 74 | 75 | const QString filter = filterRegex.match(term).captured(1); 76 | 77 | // Create matches and pass in value of private window flag 78 | matches.append(createProfileMatches(filter, privateWindow)); 79 | 80 | // If private window flag is not set and private windows should always be shown create matches 81 | if (!privateWindow && showAlwaysPrivateWindows) { 82 | matches.append(createProfileMatches(filter, true)); 83 | } 84 | 85 | context.addMatches(matches); 86 | } 87 | 88 | void FirefoxRunner::run(const RunnerContext & /*context*/, const QueryMatch &match) 89 | { 90 | const QMap data = match.data().toMap(); 91 | QStringList args = {"-P", data.value("name").toString()}; 92 | QString localLaunchCommand = launchCommand; 93 | // Private window if data has private window key or the action exists 94 | if (data.contains("private-window") || match.selectedAction()) { 95 | args.append("-private-window"); 96 | } 97 | 98 | QProcess::startDetached(localLaunchCommand, args); 99 | } 100 | 101 | QueryMatch FirefoxRunner::createMatch(const QString &text, const QMap &data, float relevance) 102 | { 103 | QueryMatch match(this); 104 | match.setIconName(data.contains("private-window") ? firefoxPrivateWindowIcon : firefoxIcon); 105 | match.setText(text); 106 | match.setData(data); 107 | match.setRelevance(relevance); 108 | #if KRUNNER_VERSION_MAJOR == 5 109 | match.setType(QueryMatch::ExactMatch); 110 | #else 111 | match.setCategoryRelevance(QueryMatch::CategoryRelevance::Highest); 112 | #endif 113 | if (privateWindowsAsActions) { 114 | match.setActions(matchActions); 115 | } 116 | return match; 117 | } 118 | 119 | QList FirefoxRunner::createProfileMatches(const QString &filter, const bool privateWindow) 120 | { 121 | QList<::QueryMatch> matches; 122 | for (const auto &profile : qAsConst(profiles)) { 123 | if (profile.name.startsWith(filter, Qt::CaseInsensitive)) { 124 | QMap data; 125 | data.insert("name", profile.launchName); 126 | if (privateWindow) 127 | data.insert("private-window", "true"); 128 | // Hide default profile 129 | if (profile.isDefault && hideDefaultProfile && !privateWindow) { 130 | continue; 131 | } 132 | QString text = profile.name; 133 | if (privateWindow) 134 | text.prepend("Private Window "); 135 | if (profile.isDefault) 136 | text.append(" (default)"); 137 | 138 | float priority = (float)profile.priority / 100; 139 | if (privateWindow && profile.privateWindowPriority != 0) { 140 | priority = (float)profile.privateWindowPriority / 100; 141 | } else if (privateWindow) { 142 | priority = (float)profile.priority / 101; 143 | } 144 | 145 | matches.append(createMatch(text, data, priority)); 146 | } 147 | } 148 | return matches; 149 | } 150 | 151 | K_PLUGIN_CLASS_WITH_JSON(FirefoxRunner, "firefoxprofilerunner.json") 152 | 153 | #include "firefoxprofilerunner.moc" 154 | #include "moc_firefoxprofilerunner.cpp" 155 | -------------------------------------------------------------------------------- /src/firefoxprofilerunner.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "profile/Profile.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #if KRUNNER_VERSION_MAJOR == 5 10 | using namespace Plasma; 11 | #include 12 | #else 13 | using namespace KRunner; 14 | #include 15 | #endif 16 | 17 | class FirefoxRunner : public AbstractRunner 18 | { 19 | Q_OBJECT 20 | 21 | public: 22 | FirefoxRunner(QObject *parent, const KPluginMetaData &data, const QVariantList &args); 23 | 24 | // NOTE: Prefixes need to be included in filterRegex. 25 | QLatin1String shortPrefix = QLatin1String("ff"); 26 | QLatin1String mediumPrefix = QLatin1String("fire"); 27 | const QRegularExpression filterRegex = QRegularExpression(R"(^(?:ff|fire\w*)(?: (.+))$)", QRegularExpression::CaseInsensitiveOption); 28 | const QRegularExpression privateWindowFlagRegex = QRegularExpression(R"((\s+-p\b))", QRegularExpression::CaseInsensitiveOption); 29 | 30 | QString launchCommand; 31 | QList profiles; 32 | bool hideDefaultProfile, showAlwaysPrivateWindows; 33 | QString firefoxIcon; 34 | const QString firefoxPrivateWindowIcon; 35 | bool privateWindowsAsActions; 36 | #if KRUNNER_VERSION_MAJOR == 5 37 | QList matchActions; 38 | #else 39 | KRunner::Actions matchActions; 40 | #endif 41 | 42 | QList createProfileMatches(const QString &filter, bool privateWindow); 43 | QueryMatch createMatch(const QString &text, const QMap &data, float relevance); 44 | 45 | public: // AbstractRunner API 46 | void reloadConfiguration() override; 47 | void match(RunnerContext &context) override; 48 | void run(const RunnerContext &context, const QueryMatch &match) override; 49 | }; 50 | -------------------------------------------------------------------------------- /src/firefoxprofilerunner.json.in: -------------------------------------------------------------------------------- 1 | { 2 | "KPlugin": { 3 | "Authors": [ 4 | { 5 | "Email": "alex1701c.dev@gmx.net", 6 | "Name": "Alex1701c" 7 | } 8 | ], 9 | "Description": "Krunner plugin to launch Firefox profiles", 10 | "EnabledByDefault": true, 11 | "Icon": "firefox", 12 | "License": "GPLv3", 13 | "Name": "FirefoxProfileRunner", 14 | "Version": "@CMAKE_PROJECT_VERSION@", 15 | "Website": "https://github.com/alex1701c/krunner-firefox" 16 | }, 17 | "X-KDE-ConfigModule": "krunner/kcms/kcm_firefoxprofilerunner" 18 | } 19 | -------------------------------------------------------------------------------- /src/private_browsing_firefox.svg: -------------------------------------------------------------------------------- 1 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /src/profile/Profile.cpp: -------------------------------------------------------------------------------- 1 | #include "Profile.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | /** 8 | * Write/Overwrite the config of the Desktop Actions for normal/private windows 9 | * @param firefoxConfig 10 | * @param initialPriority 11 | */ 12 | void Profile::writeSettings(KSharedConfigPtr firefoxConfig, int initialPriority) const 13 | { 14 | // Write settings for normal window 15 | KConfigGroup profileNormalConfig = firefoxConfig->group("Desktop Action new-window-with-profile-" + this->path); 16 | if (!profileNormalConfig.readEntry("Edited", false)) { 17 | profileNormalConfig.writeEntry("Name", this->name.isEmpty() ? this->launchName : this->name); 18 | } 19 | profileNormalConfig.writeEntry("LaunchName", this->launchName); 20 | profileNormalConfig.writeEntry("Edited", profileNormalConfig.readEntry("Edited", "false")); 21 | profileNormalConfig.writeEntry("Priority", profileNormalConfig.readEntry("Priority", QString::number(initialPriority))); 22 | profileNormalConfig.writeEntry("Exec", this->launchCommand + " -P \"" + this->launchName + "\""); 23 | 24 | // Write settings for private window 25 | KConfigGroup profilePrivateConfig = firefoxConfig->group("Desktop Action new-private-window-with-profile-" + this->path); 26 | if (!profilePrivateConfig.readEntry("Edited", false)) { 27 | profilePrivateConfig.writeEntry("Name", this->name.isEmpty() ? this->launchName : this->name); 28 | } 29 | profilePrivateConfig.writeEntry("LaunchName", this->launchName); 30 | profilePrivateConfig.writeEntry("Icon", "private_browsing_firefox"); 31 | profilePrivateConfig.writeEntry("Edited", profileNormalConfig.readEntry("Edited", false)); 32 | profilePrivateConfig.writeEntry("Exec", this->launchCommand + " -P \"" + this->launchName + "\" -private-window"); 33 | } 34 | 35 | /** 36 | * Write changes from the config dialog to the firefox.desktop file 37 | * @param firefoxConfig 38 | */ 39 | void Profile::writeConfigChanges(KSharedConfigPtr firefoxConfig) const 40 | { 41 | // General config/normal launch option 42 | KConfigGroup profileConfig = firefoxConfig->group("Desktop Action new-window-with-profile-" + this->path); 43 | profileConfig.writeEntry("Name", this->name); 44 | profileConfig.writeEntry("Edited", true); 45 | profileConfig.writeEntry("Exec", this->launchCommand + " -P \"" + this->launchName + "\""); 46 | profileConfig.writeEntry("Priority", this->priority); 47 | profileConfig.writeEntry("PrivateWindowPriority", this->privateWindowPriority); 48 | 49 | // Private window launch options 50 | KConfigGroup privateDesktopAction = firefoxConfig->group("Desktop Action new-private-window-with-profile-" + this->path); 51 | privateDesktopAction.writeEntry("Name", this->name); 52 | privateDesktopAction.writeEntry("Exec", this->launchCommand + " -P \"" + this->launchName + "\" -private-window"); 53 | } 54 | 55 | QDebug operator<<(QDebug debug, const Profile &profile) 56 | { 57 | debug << "Profile(name: " << profile.name // 58 | << " launchCommand: " << profile.launchCommand // 59 | << " launchName: " << profile.launchName // 60 | << " path: " << profile.path // 61 | << " priority: " << profile.priority // 62 | << " isDefault: " << profile.isDefault // 63 | << " isEdited: " << profile.isEdited // 64 | << " privateWindowPriority: " << profile.privateWindowPriority // 65 | << ")"; 66 | return debug; 67 | } 68 | -------------------------------------------------------------------------------- /src/profile/Profile.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | class Profile 8 | { 9 | public: 10 | QString name; 11 | QString launchCommand; 12 | QString launchName; 13 | QString path; 14 | int priority; 15 | bool isDefault; 16 | bool isEdited; 17 | int privateWindowPriority = 0; 18 | 19 | void writeSettings(KSharedConfigPtr firefoxConfig, int initialPriority = 0) const; 20 | 21 | void writeConfigChanges(KSharedConfigPtr firefoxConfig) const; 22 | }; 23 | QDebug operator<<(QDebug debug, const Profile &profile); 24 | -------------------------------------------------------------------------------- /src/profile/ProfileManager.cpp: -------------------------------------------------------------------------------- 1 | #include "ProfileManager.h" 2 | 3 | #include "firefox_debug.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | // clazy:excludeall=use-static-qregularexpression 12 | 13 | ProfileManager::ProfileManager() 14 | { 15 | initializeDesktopFileCopy(); 16 | firefoxProfilesIniPath = QDir::homePath() + "/.mozilla/firefox/profiles.ini"; 17 | firefoxDesktopFile = getDesktopFilePath(); 18 | launchCommand = getLaunchCommand(); 19 | defaultPath = getDefaultProfilePath(); 20 | } 21 | 22 | /** 23 | * Synchronizes profiles with firefox.desktop file based on forceSync and settings, returns custom profiles 24 | * @param forceSync 25 | */ 26 | QList ProfileManager::syncAndGetCustomProfiles(KConfigGroup &grp, bool forceSync) 27 | { 28 | KSharedConfigPtr firefoxConfig = KSharedConfig::openConfig(firefoxDesktopFile); 29 | firefoxConfig->reparseConfiguration(); 30 | grp.config()->reparseConfiguration(); 31 | const QString lastHash = grp.readEntry("lastHash"); 32 | bool hasChanged = false; 33 | QFile file(firefoxProfilesIniPath); 34 | if (file.open(QFile::ReadOnly)) { 35 | QCryptographicHash hash(QCryptographicHash::Md5); 36 | if (hash.addData(&file)) { 37 | const QString newHash = hash.result().toHex(); 38 | grp.writeEntry("lastHash", newHash); 39 | hasChanged = lastHash != newHash; 40 | } 41 | } 42 | if (forceSync || hasChanged) { 43 | QList firefoxProfiles = getFirefoxProfiles(); 44 | syncDesktopFile(firefoxProfiles, firefoxConfig, grp); 45 | } 46 | return getCustomProfiles(firefoxConfig); 47 | } 48 | 49 | /** 50 | * Get raw profiles from profiles.ini file, these contain just the name, path and launch command 51 | */ 52 | QList ProfileManager::getFirefoxProfiles() 53 | { 54 | QList profiles; 55 | const KSharedConfigPtr firefoxProfilesIni = KSharedConfig::openConfig(firefoxProfilesIniPath, KConfig::NoGlobals); 56 | firefoxProfilesIni->reparseConfiguration(); 57 | const QStringList configs = firefoxProfilesIni->groupList().filter(QRegularExpression(R"(Profile.*)")); 58 | 59 | for (const auto &profileEntry : configs) { 60 | Profile profile; 61 | KConfigGroup profileConfig = firefoxProfilesIni->group(profileEntry); 62 | profile.launchCommand = launchCommand; 63 | profile.launchName = profileConfig.readEntry("Name"); 64 | profile.path = profileConfig.readEntry("Path"); 65 | profiles.append(profile); 66 | } 67 | return profiles; 68 | } 69 | 70 | /** 71 | * Read profiles from firefox.desktop file, these profiles have priority etc. configured 72 | * @param firefoxConfig KSharedConfigPtr of firefox.desktop file 73 | */ 74 | QList ProfileManager::getCustomProfiles(KSharedConfigPtr firefoxConfig) 75 | { 76 | Q_ASSERT(firefoxConfig); 77 | QList profiles; 78 | const QStringList installedProfiles = firefoxConfig->groupList().filter(QRegularExpression("Desktop Action new-window-with-profile-.*")); 79 | for (const auto &profileGroupName : installedProfiles) { 80 | auto profileGroup = firefoxConfig->group(profileGroupName); 81 | if (!profileGroup.exists() || profileGroup.keyList().isEmpty()) { 82 | continue; 83 | } 84 | Profile profile; 85 | profile.name = profileGroup.readEntry("Name"); 86 | profile.launchName = profileGroup.readEntry("LaunchName"); 87 | profile.path = QString(profileGroupName).remove("Desktop Action new-window-with-profile-"); 88 | if (defaultPath == "") { 89 | defaultPath = profile.path; 90 | } 91 | profile.isDefault = profile.path == defaultPath; 92 | profile.isEdited = profileGroup.readEntry("Edited", false); 93 | profile.priority = profileGroup.readEntry("Priority", 0); 94 | profile.launchCommand = launchCommand; 95 | profile.privateWindowPriority = profileGroup.readEntry("PrivateWindowPriority", 0); 96 | profiles.append(profile); 97 | } 98 | std::sort(profiles.begin(), profiles.end(), [](const Profile &profile1, const Profile &profile2) -> bool { 99 | return profile1.priority > profile2.priority; 100 | }); 101 | qCDebug(FIREFOX) << "Found profiles: " << profiles.count(); 102 | qCDebug(FIREFOX) << "Listing data of profiles:" << profiles; 103 | return profiles; 104 | } 105 | 106 | /** 107 | * Install/Update/Delete profiles from firefox.desktop files and update the registered Desktop Actions 108 | */ 109 | void ProfileManager::syncDesktopFile(const QList &profiles, KSharedConfigPtr firefoxConfig, const KConfigGroup &config) 110 | { 111 | Q_ASSERT(firefoxConfig); 112 | Q_ASSERT(config.isValid()); 113 | KConfigGroup generalConfig = firefoxConfig->group("Desktop Entry"); 114 | const QStringList installedProfiles = firefoxConfig->groupList().filter(QRegularExpression("Desktop Action new-window-with-profile-.*")); 115 | 116 | // Update/mark to delete installed profiles 117 | for (auto &installedProfile : installedProfiles) { 118 | bool found = false; 119 | for (const auto &profile : profiles) { 120 | if (installedProfile == "Desktop Action new-window-with-profile-" + profile.path) { 121 | found = true; 122 | if (profile.launchName != firefoxConfig->group(installedProfile).readEntry("LaunchName")) { 123 | qCDebug(FIREFOX) << "Update " << profile.launchName; 124 | profile.writeSettings(firefoxConfig); 125 | } 126 | } 127 | } 128 | if (!found) { 129 | qCDebug(FIREFOX) << "Delete " << installedProfile; 130 | // Delete normal and private window Desktop Action 131 | const QString profileName = QString(installedProfile).remove("Desktop Action new-window-with-profile-"); 132 | firefoxConfig->deleteGroup(installedProfile); 133 | firefoxConfig->deleteGroup("Desktop Action new-private-window-with-profile-" + profileName); 134 | firefoxConfig->deleteGroup("Desktop Action new-private-window-with-profile-" + profileName); 135 | } 136 | } 137 | // Add group and register action 138 | int idx = 1; 139 | for (const auto &profile : profiles) { 140 | if (!firefoxConfig->hasGroup("Desktop Action new-window-with-profile-" + profile.path)) { 141 | qCDebug(FIREFOX) << "Install " << profile.launchName; 142 | // Write settings for normal and private window 143 | profile.writeSettings(firefoxConfig, idx); 144 | ++idx; 145 | } 146 | } 147 | firefoxConfig->sync(); 148 | 149 | bool enableNormal = config.readEntry(Config::RegisterNormalWindows, true); 150 | bool enablePrivate = config.readEntry(Config::RegisterPrivateWindows, true); 151 | changeProfileRegistering(enableNormal, enablePrivate, firefoxConfig); 152 | } 153 | 154 | /** 155 | * Register/Unregister Desktop Actions 156 | * @param enableNormal 157 | * @param enablePrivate 158 | * @param firefoxConfig 159 | */ 160 | void ProfileManager::changeProfileRegistering(bool enableNormal, bool enablePrivate, KSharedConfigPtr firefoxConfig) 161 | { 162 | QString registeredActions = "new-window;new-private-window;"; 163 | if (firefoxDesktopFile.endsWith("firefox-esr.desktop")) { 164 | registeredActions.clear(); 165 | } 166 | QStringList desktopActions = firefoxConfig->groupList().filter("Desktop Action"); 167 | for (auto &groupName : desktopActions) { 168 | if (firefoxConfig->group(groupName).keyList().isEmpty()) { 169 | continue; 170 | } 171 | if (enableNormal && groupName.startsWith("Desktop Action new-window-with-profile")) { 172 | registeredActions.append(groupName.remove("Desktop Action ") + ";"); 173 | } else if (enablePrivate && groupName.startsWith("Desktop Action new-private-window-with-profile-")) { 174 | registeredActions.append(groupName.remove("Desktop Action ") + ";"); 175 | } 176 | } 177 | qCDebug(FIREFOX) << "Registered Desktop Actions:\n" << registeredActions; 178 | firefoxConfig->group("Desktop Entry").writeEntry("Actions", registeredActions); 179 | firefoxConfig->group("Desktop Entry").sync(); 180 | } 181 | 182 | /** 183 | * Get launch command from .desktop file, this command is different in firefox-esr 184 | */ 185 | QString ProfileManager::getLaunchCommand() const 186 | { 187 | return KSharedConfig::openConfig(firefoxDesktopFile)->group("Desktop Entry").readEntry("Exec").remove(" %u"); 188 | } 189 | 190 | /** 191 | * Get the Path property of the default profile 192 | */ 193 | QString ProfileManager::getDefaultProfilePath() const 194 | { 195 | const KSharedConfigPtr firefoxProfilesIni = KSharedConfig::openConfig(firefoxProfilesIniPath); 196 | const QStringList configs = firefoxProfilesIni->groupList(); 197 | const QStringList installConfig = configs.filter(QRegularExpression(R"(Install.*)")); 198 | QString path; 199 | if (!installConfig.empty()) { 200 | path = firefoxProfilesIni->group(installConfig.first()).readEntry("Default"); 201 | } 202 | if (!path.isEmpty()) { 203 | return path; 204 | } 205 | for (const auto &profileName : firefoxProfilesIni->groupList().filter(QRegularExpression(R"(Profile.*)"))) { 206 | const auto profile = firefoxProfilesIni->group(profileName); 207 | if (profile.readEntry("Default", 0) == 1) { 208 | return profile.readEntry("Path"); 209 | } 210 | } 211 | return ""; 212 | } 213 | 214 | /** 215 | * Get path to firefox*.desktop file, checks both options for firefox and firefox-esr 216 | */ 217 | QString ProfileManager::getDesktopFilePath(bool quiet) 218 | { 219 | for (const QString &name : firefoxDesktopNames) { 220 | QString file(QDir::homePath() + "/.local/share/applications/" + name + ".desktop"); 221 | if (QFile::exists(file)) { 222 | return file; 223 | } 224 | } 225 | if (!quiet) { 226 | qWarning() << "Can not find a firefox.desktop, org.mozilla.firefox.desktop or firefox-esr.desktop file in ~/.local/share/applications/"; 227 | } 228 | return QString(); 229 | } 230 | 231 | QString ProfileManager::iconForExecutable() const 232 | { 233 | return launchCommand.endsWith("firefox") ? "firefox" : "firefox-esr"; 234 | } 235 | 236 | void ProfileManager::initializeDesktopFileCopy() 237 | { 238 | if (ProfileManager::getDesktopFilePath(true).isEmpty()) { 239 | QDir localAppDir(QDir::homePath() + "/.local/share/applications/"); 240 | localAppDir.mkpath("."); 241 | for (const QString &name : firefoxDesktopNames) { 242 | if (const auto &service = KService::serviceByDesktopName(name)) { 243 | QFile::copy(service->entryPath(), QDir::homePath() + "/.local/share/applications/" + name + ".desktop"); 244 | } 245 | } 246 | } 247 | } 248 | -------------------------------------------------------------------------------- /src/profile/ProfileManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Profile.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | class ProfileManager 10 | { 11 | public: 12 | ProfileManager(); 13 | 14 | QList syncAndGetCustomProfiles(KConfigGroup &grp, bool forceSync = false); 15 | QList getFirefoxProfiles(); 16 | QList getCustomProfiles(KSharedConfigPtr firefoxConfig); 17 | 18 | void syncDesktopFile(const QList &profiles, KSharedConfigPtr firefoxConfig, const KConfigGroup &config); 19 | void changeProfileRegistering(bool enableNormal, bool enablePrivate, KSharedConfigPtr firefoxConfig); 20 | 21 | QString getLaunchCommand() const; 22 | QString getDefaultProfilePath() const; 23 | QString getDesktopFilePath(bool quiet = false); 24 | 25 | QString iconForExecutable() const; 26 | 27 | QString firefoxDesktopFile, launchCommand, defaultPath, firefoxProfilesIniPath; 28 | 29 | private: 30 | void initializeDesktopFileCopy(); 31 | QStringList firefoxDesktopNames{ 32 | QStringLiteral("firefox"), 33 | QStringLiteral("org.mozilla.firefox"), 34 | QStringLiteral("firefox-esr"), 35 | }; 36 | }; 37 | -------------------------------------------------------------------------------- /test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | find_package(Qt${QT_MAJOR_VERSION}Test REQUIRED) 2 | include(ECMAddTests) 3 | 4 | ecm_add_test(ProfileManagerTest.cpp TEST_NAME profile_manager_test) 5 | set_tests_properties(profile_manager_test PROPERTIES ENVIRONMENT "QT_QPA_PLATFORM=offscreen") 6 | target_link_libraries(profile_manager_test 7 | Qt::Test 8 | Qt::Core 9 | Qt::Gui 10 | KF${QT_MAJOR_VERSION}::CoreAddons 11 | KF${QT_MAJOR_VERSION}::ConfigCore 12 | KF${QT_MAJOR_VERSION}::I18n 13 | KF${QT_MAJOR_VERSION}::Runner 14 | core_STATIC 15 | ) 16 | -------------------------------------------------------------------------------- /test/Config.h: -------------------------------------------------------------------------------- 1 | #ifndef FIREFOXPROFILERUNNER_CONFIG_H 2 | #define FIREFOXPROFILERUNNER_CONFIG_H 3 | 4 | #include 5 | namespace 6 | { 7 | class Config 8 | { 9 | public: 10 | // General settings 11 | static const QString ConfigDir; 12 | static const QString ConfigFile; 13 | constexpr static const auto MainGroup = "Config"; 14 | constexpr static const auto HideDefaultProfile = "hideDefaultProfile"; 15 | constexpr static const auto ShowAlwaysPrivateWindows = "showAlwaysPrivateWindows"; 16 | 17 | // Profile settings 18 | constexpr static const auto RegisterNormalWindows = "registerNormalWindows"; 19 | constexpr static const auto RegisterPrivateWindows = "registerPrivateWindows"; 20 | constexpr static const auto PrivateWindowAction = "privateWindowActions"; 21 | // UI settings 22 | constexpr static const auto GeneralMinimized = "generalMinimized"; 23 | }; 24 | } 25 | 26 | const QString Config::ConfigDir = QDir::homePath() + "/.config/krunnerplugins/"; 27 | const QString Config::ConfigFile = Config::ConfigDir + "firefoxprofilerunnerrc"; 28 | 29 | #endif // FIREFOXPROFILERUNNER_CONFIG_H 30 | -------------------------------------------------------------------------------- /test/ProfileManagerTest.cpp: -------------------------------------------------------------------------------- 1 | #include "../src/profile/ProfileManager.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | inline int getSplitCount(const QString str) 9 | { 10 | return str.split(";", Qt::SkipEmptyParts).count(); 11 | } 12 | 13 | class ProfileManagerTest : public QObject 14 | { 15 | Q_OBJECT 16 | 17 | private Q_SLOTS: 18 | void initTestCase() 19 | { 20 | QStandardPaths::setTestModeEnabled(true); 21 | } 22 | 23 | /** 24 | * Test if the profiles are read correctly 25 | * The profiles file that is read contains an Install.* group 26 | */ 27 | static void testReadProfilesFromWithInstallGroup() 28 | { 29 | ProfileManager manager; 30 | manager.firefoxProfilesIniPath = QFINDTESTDATA("resources/profiles_install.ini"); 31 | manager.defaultPath = manager.getDefaultProfilePath(); 32 | QList rawProfiles = manager.getFirefoxProfiles(); 33 | 34 | QVERIFY(QFile::exists(manager.firefoxProfilesIniPath)); 35 | QCOMPARE(rawProfiles.size(), 2); 36 | QCOMPARE(manager.getDefaultProfilePath(), "snytc8pd.default-release-1"); 37 | } 38 | 39 | /** 40 | * Test if the profiles are read correctly if the default information 41 | * is contained within a Profile.* group 42 | */ 43 | static void testReadProfilesFromWithoutInstallGroup() 44 | { 45 | ProfileManager manager; 46 | manager.firefoxProfilesIniPath = QFINDTESTDATA("resources/profiles.ini"); 47 | manager.defaultPath = manager.getDefaultProfilePath(); 48 | QList rawProfiles = manager.getFirefoxProfiles(); 49 | 50 | QVERIFY(QFile::exists(manager.firefoxProfilesIniPath)); 51 | QCOMPARE(rawProfiles.size(), 2); 52 | QCOMPARE(manager.getDefaultProfilePath(), "x4wpq9zm.default"); 53 | } 54 | 55 | /** 56 | * Read profiles and sync them with the firefox.desktop file 57 | * Test if the default profile is read correctly and if the registering of 58 | * the Desktop Actions works correctly 59 | */ 60 | static void testSyncAndReadInstalledProfile() 61 | { 62 | ProfileManager manager; 63 | manager.firefoxProfilesIniPath = QFINDTESTDATA("resources/profiles_install.ini"); 64 | manager.defaultPath = manager.getDefaultProfilePath(); 65 | 66 | QFile source(QFINDTESTDATA("resources/firefox.desktop")); 67 | source.open(QIODevice::ReadOnly); 68 | 69 | QTemporaryFile file; 70 | file.open(); 71 | file.write(source.readAll()); 72 | file.close(); 73 | const auto firefoxConfig = KSharedConfig::openConfig(file.fileName(), KConfig::NoGlobals); 74 | QList rawProfiles = manager.getFirefoxProfiles(); 75 | KConfigGroup config = KSharedConfig::openConfig("tmpconfig")->group("Config"); 76 | 77 | // Check if Desktop Actions are created and if they are registered 78 | QCOMPARE(rawProfiles.size(), 2); 79 | manager.syncDesktopFile(rawProfiles, firefoxConfig, config); 80 | QCOMPARE(firefoxConfig->groupList().filter(QRegularExpression(R"(^Desktop Action new-(?:private-)?window-with-profile)")).size(), 4); 81 | manager.changeProfileRegistering(true, true, firefoxConfig); 82 | firefoxConfig->sync(); 83 | QCOMPARE(getSplitCount(firefoxConfig->group("Desktop Entry").readEntry("Actions")), 6); 84 | 85 | // Unregister private windows 86 | manager.changeProfileRegistering(true, false, firefoxConfig); 87 | QCOMPARE(getSplitCount(firefoxConfig->group("Desktop Entry").readEntry("Actions")), 4); 88 | QCOMPARE( 89 | firefoxConfig->group("Desktop Entry").readEntry("Actions").split(";").filter(QRegularExpression(R"(^new-private-window-with-profile)")).count(), 90 | 0); 91 | 92 | // Unregister all windows 93 | manager.changeProfileRegistering(false, false, firefoxConfig); 94 | QCOMPARE(getSplitCount(firefoxConfig->group("Desktop Entry").readEntry("Actions")), 2); 95 | 96 | // Register all options 97 | manager.changeProfileRegistering(true, true, firefoxConfig); 98 | QCOMPARE(getSplitCount(firefoxConfig->group("Desktop Entry").readEntry("Actions")), 6); 99 | 100 | // Check if profiles are read correctly 101 | QList customProfiles = manager.getCustomProfiles(firefoxConfig); 102 | QCOMPARE(customProfiles.count(), 2); 103 | for (const auto &profile : customProfiles) { 104 | if (profile.name == "Alex") { 105 | QVERIFY(profile.isDefault); 106 | } 107 | } 108 | } 109 | 110 | /** 111 | * Test if the plugin correctly reacts if profiles are added and deleted 112 | */ 113 | static void testAddingAndDeletingOfProfiles() 114 | { 115 | QFile sourceFile(QFINDTESTDATA("resources/profiles_install.ini")); 116 | QVERIFY(sourceFile.open(QIODevice::ReadOnly)); 117 | QTemporaryFile profilesFile; 118 | profilesFile.open(); 119 | profilesFile.write(sourceFile.readAll()); 120 | profilesFile.close(); 121 | 122 | QFile source(QFINDTESTDATA("resources/firefox.desktop")); 123 | source.open(QIODevice::ReadOnly); 124 | QTemporaryFile desktopFile; 125 | QVERIFY(desktopFile.open()); 126 | desktopFile.write(source.readAll()); 127 | desktopFile.close(); 128 | 129 | ProfileManager manager; 130 | manager.firefoxProfilesIniPath = profilesFile.fileName(); 131 | manager.defaultPath = manager.getDefaultProfilePath(); 132 | manager.firefoxDesktopFile = desktopFile.fileName(); 133 | 134 | const auto firefoxConfig = KSharedConfig::openConfig(manager.firefoxDesktopFile); 135 | firefoxConfig->reparseConfiguration(); 136 | QList rawProfiles = manager.getFirefoxProfiles(); 137 | KConfigGroup _config = KSharedConfig::openConfig("tmp")->group("Config"); 138 | _config.config()->reparseConfiguration(); 139 | 140 | // Check if Desktop Actions are created and if they are registered 141 | QCOMPARE(rawProfiles.size(), 2); 142 | manager.syncDesktopFile(rawProfiles, firefoxConfig, _config); 143 | firefoxConfig->sync(); 144 | QCOMPARE(firefoxConfig->groupList().filter(QRegularExpression(R"(^Desktop Action new-(?:private-)?window-with-profile)")).size(), 4); 145 | manager.changeProfileRegistering(true, true, firefoxConfig); 146 | QCOMPARE(getSplitCount(firefoxConfig->group("Desktop Entry").readEntry("Actions")), 6); 147 | 148 | // Delete group and check if it and its registered actions has been removed 149 | firefoxConfig->deleteGroup("Desktop Action new-private-window-with-profile-snytc8pd.default-release-1"); 150 | manager.changeProfileRegistering(false, true, firefoxConfig); 151 | QCOMPARE(getSplitCount(firefoxConfig->group("Desktop Entry").readEntry("Actions")), 3); 152 | QCOMPARE(firefoxConfig->group("Desktop Entry").readEntry("Actions").split(";").filter(QRegularExpression(R"(^new-private-window)")).count(), 2); 153 | 154 | // Add new profile 155 | { 156 | QFile firefoxProfilesAppend(profilesFile.fileName()); 157 | QVERIFY(firefoxProfilesAppend.open(QFile::Append)); 158 | firefoxProfilesAppend.write("\n[Profile42]\nName=New Profile\nIsRelative=1\nPath=71lye2uh42.New Profile\n"); 159 | } 160 | 161 | auto firefoxProfiles = manager.getFirefoxProfiles(); 162 | QCOMPARE(firefoxProfiles.size(), 3); 163 | QCOMPARE(firefoxConfig->groupList().filter(QRegularExpression(R"(^Desktop Action new-(?:private-)?window-with-profile)")).size(), 3); 164 | 165 | manager.syncDesktopFile(firefoxProfiles, firefoxConfig, _config); 166 | auto newCustomProfiles = manager.getCustomProfiles(firefoxConfig); 167 | QCOMPARE(newCustomProfiles.size(), 3); 168 | manager.changeProfileRegistering(true, true, firefoxConfig); 169 | qWarning() << firefoxConfig->groupList().filter(QRegularExpression(R"(^Desktop Action new-)")); 170 | QCOMPARE(firefoxConfig->groupList().filter(QRegularExpression(R"(^Desktop Action new-)")).size(), 7); 171 | QCOMPARE(firefoxConfig->group("Desktop Entry").readEntry("Actions").split(";", Qt::SkipEmptyParts).count(), 7); 172 | } 173 | }; 174 | 175 | QTEST_MAIN(ProfileManagerTest) 176 | 177 | #include "ProfileManagerTest.moc" 178 | -------------------------------------------------------------------------------- /test/resources/firefox.desktop: -------------------------------------------------------------------------------- 1 | [Desktop Entry] 2 | Version=1.0 3 | Name=Firefox Web Browser 4 | Comment=Browse the World Wide Web 5 | GenericName=Web Browser 6 | Keywords=Internet;WWW;Browser;Web;Explorer 7 | Exec=firefox %u 8 | Terminal=false 9 | X-MultipleArgs=false 10 | Type=Application 11 | Icon=firefox 12 | Categories=GNOME;GTK;Network;WebBrowser; 13 | MimeType=text/html;text/xml;application/xhtml+xml;application/xml;application/rss+xml;application/rdf+xml;image/gif;image/jpeg;image/png;x-scheme-handler/http;x-scheme-handler/https;x-scheme-handler/ftp;x-scheme-handler/chrome;video/webm;application/x-xpinstall; 14 | StartupNotify=true 15 | Actions=new-window;new-private-window; 16 | 17 | [Desktop Action new-window] 18 | Name=Open a New Window 19 | Exec=firefox -new-window 20 | 21 | [Desktop Action new-private-window] 22 | Name=Open a New Private Window 23 | Exec=firefox -private-window 24 | -------------------------------------------------------------------------------- /test/resources/profiles.ini: -------------------------------------------------------------------------------- 1 | [General] 2 | StartWithLastProfile=1 3 | 4 | [Profile0] 5 | Name=default 6 | IsRelative=1 7 | Path=x4wpq9zm.default 8 | Default=1 9 | 10 | [Profile1] 11 | Name=New Profile 12 | IsRelative=1 13 | Path=71lye2uh.New Profile 14 | 15 | -------------------------------------------------------------------------------- /test/resources/profiles_install.ini: -------------------------------------------------------------------------------- 1 | [Install4F96D1932A9F858E] 2 | Default=snytc8pd.default-release-1 3 | Locked=1 4 | 5 | [Profile1] 6 | Name=Secure Profile 7 | IsRelative=1 8 | Path=fuu0zoxe.SecureUser 9 | 10 | [Profile0] 11 | Name=Alex 12 | IsRelative=1 13 | Path=snytc8pd.default-release-1 14 | 15 | [General] 16 | StartWithLastProfile=1 17 | Version=2 18 | 19 | -------------------------------------------------------------------------------- /uninstall.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Exit if something fails 4 | set -e 5 | 6 | cd build 7 | sudo make uninstall 8 | 9 | # KRunner needs to be restarted for the changes to be applied 10 | krunner_version=$(krunner --version | grep -oP "(?<=krunner )\d+") 11 | if pgrep -x krunner > /dev/null 12 | then 13 | kquitapp$krunner_version krunner 14 | fi 15 | 16 | --------------------------------------------------------------------------------