Update CHANGELOG

Add system tray icon and implement ability to close to system tray (Windows)

CHANGELOG

@@ -1,30 +1,91 @@
-0.9.0-RC6 / February 13, 2016
+
+Latest Release: 
+Robomongo 0.9.0 Final (30 Sep, 2016)
+http://blog.robomongo.org/robomongo-0-9-0-final/
+
+Robomongo 0.9.0:
+  Major Features: 
+    - Support for MongoDB 3.x and WiredTiger engine. Robomongo now embeds MongoDB 3.2 shell. 
+      (Ability to use the latest shell functionality)
+    - SSH tunnel support for connections added.
+    - SSL tunnel support added. 
+    - MongoDB Atlas (Cloud MongoDB) support added.
+    - Both MONGODB-CR and SCRAM-SHA-1 authentication mechanisms are supported. 
+    - Allow direct connections to Replica Set members and support IPv6 protocol. 
+    - Loading of huge list of collections is now faster.
+    - Create Collection dialog is now expandable to support all advanced options.
+      (Supporting all major mongoDB versions 3.2, 3.0, 2.6 and all storage engine types (WiredTiger 
+      and MMAPV1) is added.) 
+    - Windows High DPI support.
+    - Full size editor with dockable output window.
+    
+  Fixed:
+    - Incorrect representation of floating-point numbers (fixed since RC3). This bug was a reason of a big number of issues:
+      #910, #748, #697, #699, #760, #815, #870, #892, 
+      #894, #905, #945, #974, #978, #990, #831, #842
+    - SSH connection failure to servers on Ubuntu and OS X with the following error:
+      "Resource temporarily unavailable. Error when starting up SSH session: -8"  (#1090)
+
+  What's new in 0.9.0 Final (30 Sep, 2016)
+  http://blog.robomongo.org/robomongo-0-9-0-final/
+  
+    New Features:
+      - Full size editor with dockable output window.
+      - New JSON object context menu items: "Copy Name" and "Copy Path" are added.
+      - New database context menu items: "Current Operations" and "Kill Operation" are added.
+      - Minimize to Tray Icon for Windows.
+        
+    Other Changes
+      - Cloud platforms Compose, mLab and Amazon EC2 were tested and added as supported platforms.
+      - Maximize/Restore result button behavior and icon have been improved.
+      - For better code quality and code reviews, Robomongo Code Quality and Robomongo Code Review pages have been created.
+        https://github.com/paralect/robomongo/wiki/Robomongo-Code-Review
+        https://github.com/paralect/robomongo/wiki/Robomongo-Code-Quality
  
-  Most important changes: support for MongoDB 3.x and WiredTiger engine. Robomongo 
-  now embeds MongoDB 3.2 shell. It means that you can now use the latest
-  shell functionality. Both MONGODB-CR and SCRAM-SHA-1 authentication mechanisms are
-  supprted. Also, we now allow direct connections to Replica Set members and 
-  support IPv6 protocol. Loading of huge list of collections is now faster.
+  What's new in RC10 (Aug 8, 2016)
+  http://blog.robomongo.org/robomongo-rc10/
+  
+    New Features:
+      - SSL connections with advanced options are now supported.
+      - MongoDB Atlas (Cloud MongoDB) is supported.
+      - Cross Platform High DPI enhancements. 
+    
+    Enhancements:
+      - For better security, OpenSSL has been upgraded to OpenSSL 1.0.1p.
+      - Qt has been updated from Qt 5.5 to latest Qt 5.7. With this update there are many 
+        enhancements including cross platform High DPI support.
 
-  Fixed incorrect representation of floating-point numbers (fixed since RC3).
-  This bug was a reason of a big number of issues:
-
-     #910, #748, #697, #699, #760, #815, #870, #892, 
-     #894, #905, #945, #974, #978, #990, #831, #842
-
-  What's new in RC7 (March 4, 2016 )
+  What's new in RC9 (May 30, 2016)
+  http://blog.robomongo.org/robomongo-rc9/
+  
+    New Features:
+      - Create Collection dialog with advanced options.
+      - New feature has been added to save/restore window sizes. (#1102)
+      - Connection settings from previous versions of Robomongo are 
+        now automatically imported starting from Robomongo 0.9.0 RC9. (#1086)
+      - Support for querying documents by UUIDs is added, both in legacy and new encoding. (#432)
+       
+    Fixed:
+      - SSH connection failure to servers on Ubuntu and OS X with the following error:
+        "Resource temporarily unavailable. Error when starting up SSH session: -8"  (#1090)
+      - Correct handling of create/drop of databases and collections. (#1083)
+    
+  What's new in RC8 (April 14, 2016)
+  http://blog.robomongo.org/robomongo-rc8/
+     
+  What's new in RC7 (March 4, 2016)
   http://blog.robomongo.org/robomongo-rc7
 
-  What's new in RC6 (February 13, 2016 )
+  What's new in RC6 (February 13, 2016)
   http://blog.robomongo.org/ipv6-protocol
 
-  What's new in RC5 (February 8, 2016 )
+  What's new in RC5 (February 8, 2016)
   http://blog.robomongo.org/campaign-is-over-robomongo-is-not/
 
-  What's new in RC4 (February 1, 2016 )
+  What's new in RC4 (February 1, 2016)
   http://blog.robomongo.org/robomongo-rc4
 
-  What's new in RC3 (January 29, 2016 )
+  What's new in RC3 (January 29, 2016)
   http://blog.robomongo.org/robomongo-0-9-0-rc3-released
 
   What's new in RC2 (January 26, 2016)
@@ -86,7 +147,7 @@
   * [Andres Kievsky]
     - Added new app icon in a variety of png and iDraw formats (#693)
   * [Michael Steinacher]
-	- Retina text display support (#724)
+    - Retina text display support (#724)
 
 0.8.4 / November 27, 2013
 

CMakeLists.txt

@@ -8,7 +8,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
 set(PROJECT_VERSION_MAJOR "0")
 set(PROJECT_VERSION_MINOR "9")
 set(PROJECT_VERSION_PATCH "0")
-set(PROJECT_VERSION_BUILD "-RC7")
+set(PROJECT_VERSION_BUILD "")
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${PROJECT_VERSION_BUILD}")
 
 # Modules
@@ -28,13 +28,13 @@ find_package(Qt5Gui REQUIRED)
 find_package(Qt5Widgets REQUIRED)
 find_package(Qt5PrintSupport REQUIRED)
 find_package(MongoDB REQUIRED)
+find_package(OpenSSL REQUIRED)
 
 if (SYSTEM_MACOSX)
     find_package(Qt5MacExtras REQUIRED)
 endif()
 
 # Projects
-add_subdirectory(src/third-party/openssl)
 add_subdirectory(src/third-party/libssh2)
 add_subdirectory(src/robomongo/ssh)
 add_subdirectory(src/third-party/qjson)

README.md

@@ -7,13 +7,78 @@ Starting from version 0.9, Robomongo is compatibile with MongoDB 3.x (including
 
 Robomongo 0.8.x embeds the **MongoDB 2.4.0** shell.
 
+What's new in latest Robomongo 0.9.0 Final?
+====================================
+Latest release of Robomongo 0.9.0 Final includes: 
+  - Full size editor with dockable output window.
+    (Becoming the first and only MongoDB admin tool providing this feature)
+  - Two result object context menu items: "Copy Name" and "Copy Path" added.
+  - Two database context menu items: "Copy Name" and "Copy Path" added.
+  - Minimize to Tray Icon for Windows.
+  
+Central feature of this release is full size editor with dockable output window feature. With this new feature, Robomongo can be used with maximized/full size query editor with dockable/floating output window. This feature is very useful especially when you have long scripts or you just want to see output window in your second monitor.
+
+Blog:     http://blog.robomongo.org/robomongo-0-9-0-final/  
+Download: https://robomongo.org/download  
+Watch: [Robomongo youtube channel](https://www.youtube.com/channel/UCM_7WAseRWeeiBikExppstA)  
+Follow: https://twitter.com/Robomongo
+
+What's Planned for the Next Releases?
+====================================
+
+We are currently working towards [Robomongo 1.0.0 milestone](https://github.com/paralect/robomongo/milestone/18).  
+ 
+Currently in progress:
+- Replica Sets
+- Export/Import
+
+Planned for Next Release:
+- Support creating connections from connections strings
+- Support enabling SSH and SSL at the same time
+
+Plans for Future:
+- User Roles
+- Support execution of multiple simultaneous queries [#1161](https://github.com/paralect/robomongo/issues/1161)
+- Enhancements for stability, running without crashes ([Stability Milestone](https://github.com/paralect/robomongo/milestone/15))
+- More Documentation
+- Unit Tests
+- Refactoring Debug Log module
+
+Supported Platforms
+===============
+
+| MongoDB Versions      |
+| :-------------------- |
+| 3.2                   |
+| 3.0                   |
+| 2.6                   |
+
+| MongoDB Cloud Platforms|
+| :------------ |
+| MongoDB Atlas |
+| Compose       |
+| mLab          |
+| ObjectRocket  |
+| Amazon EC2    |
+
+| Windows                |   Mac            | Linux                       |        
+|:---------------------- | :---------------| :---------------------------|
+| Windows 64-bit 10      |  Mac OS X 10.11  | Linux Ubuntu 16.04 64-bit*  |
+  Windows 64-bit 8.1     |  Mac OS X 10.10  | Linux Ubuntu 14.04 64-bit*  |
+| Windows 64-bit 7       |                  | Linux CentOS 7 64-bit*      |
+|                        |                  | Linux CentOS 6 64-bit*      |
+
+\* latest stable build
+
+**Note**: Currently Robomongo supports connection to single server of a replica set. Support for connection to **Replica Sets** is planned in next release Robomongo 1.0.0.
+
 
 Download
 ========
 
 You can download tested install packages for OS X, Windows, and Linux from our site: [www.robomongo.org](http://www.robomongo.org).
 
-The latest stable release is currently **Robomongo 0.8.5**.
+The latest stable release is currently [**Robomongo 0.9.0 Final**](http://blog.robomongo.org/robomongo-0-9-0-final/).
 
 Support
 =======
@@ -29,34 +94,25 @@ You can:
 Build
 =====
 
-The wiki contains prerequisites and instructions to [Build Robomongo](https://github.com/paralect/robomongo/wiki/Build-Robomongo).
+The wiki contains prerequisites and instructions to [Build Robomongo](https://github.com/paralect/robomongo/wiki).
 
 If you want to compile from source yourself, you should be able to do so cleanly from a [release branch](https://github.com/paralect/robomongo/releases).
 
-What's Planned for the Next Release?
-====================================
-
-We are currently working toward a [0.9.0 release milestone](https://github.com/paralect/robomongo/milestones/Robomongo%200.9.0)
-with some major features targeted including compatibility with MongoDB 3.0
-(updated shell, SCRAM-SHA-1 auth, support for WiredTiger storage engine)
-and full support for replica sets.
-
 Contribute!
 ===========
 
-### Vote for Features
-
-Please view our [Magic Backlog](http://app.robomongo.org/backlog) to see features prioritised by donation. The small amount of donations we currently receive are put toward hosting costs.
-
 ### Suggest Features
 
 New feature suggestions or UI improvements are always welcome.
+[Create a new feature request on github](https://github.com/paralect/robomongo/issues/new)
 
 This project is powered by open source volunteers, so we have a limited amount of development resource to address all requests. We will certainly make best efforts to progress (particularly for those with strong community upvotes).
 
 ### Code Contributions
 
-Code contributions are always welcome! Just try to follow our coding style: [Robomongo Coding Style](https://github.com/paralect/robomongo/wiki/Robomongo-Coding-Style).
+Code contributions are always welcome! Just try to follow our pre-commit checks and coding style: 
+- [Robomongo Code Quality](https://github.com/paralect/robomongo/wiki/Robomongo-Code-Quality)
+- [Robomongo Coding Style](https://github.com/paralect/robomongo/wiki/Robomongo-Coding-Style)
 
 If you plan to contribute, please create a Github issue (or comment on the relevant existing issue) so we can help coordinate with upcoming release plans.
 
@@ -81,7 +137,7 @@ There are a number of issues we could use help with reproducing. They are marked
 License
 =======
 
-Copyright (C) 2013-2015 [Paralect, Inc](http://www.paralect.com)
+Copyright (C) 2013-2016 [Paralect, Inc](http://www.paralect.com)
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License version 3 as 

bin/tag

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+BIN_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"       # Get directory of this file
+PROJECT_DIR=$(dirname $BIN_DIR)                                   # Get root directory of project
+
+VERSION="$(echo $1 | tr '[A-Z]' '[a-z]')"
+if [ -z "$VERSION" ]; then
+    echo "Usage: tag <name>"
+    echo "Example: tag 0.9.0-rc9"
+    exit
+fi
+
+if [ "$(git rev-parse --abbrev-ref HEAD)" != "master" ]; then
+    echo "Error: You are not on master branch"
+    exit
+fi
+
+cd $PROJECT_DIR
+git tag -a "v${VERSION}" -m "${VERSION}"
+git push --tags

cmake/FindOpenSSL.cmake

@@ -0,0 +1,138 @@
+##################################################
+# Find and Add OpenSSL shared (dynamic) library 
+# 
+# - This module defines the following variables:
+#   OpenSSL_DIR
+#   OPENSSL_VERSION
+#
+# - Imported shared(dynamic) libraries "ssl" and "crypto" are created.
+#
+# - It is assumed that OpenSSL has been built and path to OpenSSL build directory is 
+#   added into system(environment) variable ROBOMONGO_CMAKE_PREFIX_PATH.
+#
+##################################################
+
+# Try to find OpenSSL directory (uses CMAKE_PREFIX_PATH locations)
+#-------------------------------------------
+
+find_path(
+    OpenSSL_DIR include/openssl/ssl.h
+    DOC "Path to OpenSSL (github.com/openssl/openssl) root directory"
+)
+
+# Find OpenSSL version
+#-------------------------------------------
+
+if(SYSTEM_WINDOWS)
+  set (OPENSSL_INCLUDE_DIR "${OpenSSL_DIR}/inc32")
+else()
+  set (OPENSSL_INCLUDE_DIR "${OpenSSL_DIR}/include")
+endif()
+
+function(from_hex HEX DEC)
+  string(TOUPPER "${HEX}" HEX)
+  set(_res 0)
+  string(LENGTH "${HEX}" _strlen)
+
+  while (_strlen GREATER 0)
+    math(EXPR _res "${_res} * 16")
+    string(SUBSTRING "${HEX}" 0 1 NIBBLE)
+    string(SUBSTRING "${HEX}" 1 -1 HEX)
+    if (NIBBLE STREQUAL "A")
+      math(EXPR _res "${_res} + 10")
+    elseif (NIBBLE STREQUAL "B")
+      math(EXPR _res "${_res} + 11")
+    elseif (NIBBLE STREQUAL "C")
+      math(EXPR _res "${_res} + 12")
+    elseif (NIBBLE STREQUAL "D")
+      math(EXPR _res "${_res} + 13")
+    elseif (NIBBLE STREQUAL "E")
+      math(EXPR _res "${_res} + 14")
+    elseif (NIBBLE STREQUAL "F")
+      math(EXPR _res "${_res} + 15")
+    else()
+      math(EXPR _res "${_res} + ${NIBBLE}")
+    endif()
+
+    string(LENGTH "${HEX}" _strlen)
+  endwhile()
+
+  set(${DEC} ${_res} PARENT_SCOPE)
+endfunction()
+
+if (OPENSSL_INCLUDE_DIR)
+  if(OPENSSL_INCLUDE_DIR AND EXISTS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h")
+    file(STRINGS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h" openssl_version_str
+         REGEX "^#[\t ]*define[\t ]+OPENSSL_VERSION_NUMBER[\t ]+0x([0-9a-fA-F])+.*")
+
+    # The version number is encoded as 0xMNNFFPPS: major minor fix patch status
+    # The status gives if this is a developer or prerelease and is ignored here.
+    # Major, minor, and fix directly translate into the version numbers shown in
+    # the string. The patch field translates to the single character suffix that
+    # indicates the bug fix state, which 00 -> nothing, 01 -> a, 02 -> b and so
+    # on.
+
+    string(REGEX REPLACE "^.*OPENSSL_VERSION_NUMBER[\t ]+0x([0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F]).*$"
+           "\\1;\\2;\\3;\\4;\\5" OPENSSL_VERSION_LIST "${openssl_version_str}")
+    list(GET OPENSSL_VERSION_LIST 0 OPENSSL_VERSION_MAJOR)
+    list(GET OPENSSL_VERSION_LIST 1 OPENSSL_VERSION_MINOR)
+    from_hex("${OPENSSL_VERSION_MINOR}" OPENSSL_VERSION_MINOR)
+    list(GET OPENSSL_VERSION_LIST 2 OPENSSL_VERSION_FIX)
+    from_hex("${OPENSSL_VERSION_FIX}" OPENSSL_VERSION_FIX)
+    list(GET OPENSSL_VERSION_LIST 3 OPENSSL_VERSION_PATCH)
+
+    if (NOT OPENSSL_VERSION_PATCH STREQUAL "00")
+      from_hex("${OPENSSL_VERSION_PATCH}" _tmp)
+      # 96 is the ASCII code of 'a' minus 1
+      math(EXPR OPENSSL_VERSION_PATCH_ASCII "${_tmp} + 96")
+      unset(_tmp)
+      # Once anyone knows how OpenSSL would call the patch versions beyond 'z'
+      # this should be updated to handle that, too. This has not happened yet
+      # so it is simply ignored here for now.
+      string(ASCII "${OPENSSL_VERSION_PATCH_ASCII}" OPENSSL_VERSION_PATCH_STRING)
+    endif ()
+
+    set(OPENSSL_VERSION "${OPENSSL_VERSION_MAJOR}.${OPENSSL_VERSION_MINOR}.${OPENSSL_VERSION_FIX}${OPENSSL_VERSION_PATCH_STRING}")
+  endif ()
+endif ()
+
+
+# Add imported ssl and crypto libraries
+#-------------------------------------------
+    
+# Add imported target ssl (ssleay32)
+add_library(ssl SHARED IMPORTED)
+
+# Add imported target for crypto (libeay32)
+add_library(crypto SHARED IMPORTED)
+    
+if(SYSTEM_WINDOWS)
+    set_target_properties(ssl PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES   "${OpenSSL_DIR}/inc32"
+        IMPORTED_IMPLIB                 "${OpenSSL_DIR}/out32dll/ssleay32.lib"
+    )
+    set_target_properties(crypto PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES   "${OpenSSL_DIR}/inc32"
+        IMPORTED_IMPLIB                 "${OpenSSL_DIR}/out32dll/libeay32.lib"
+    )
+elseif(SYSTEM_MACOSX)
+    set_target_properties(ssl PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES   "${OpenSSL_DIR}/include"
+        IMPORTED_LOCATION               "${OpenSSL_DIR}/libssl.dylib"
+    )
+    set_target_properties(crypto PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES   "${OpenSSL_DIR}/include"
+        IMPORTED_LOCATION               "${OpenSSL_DIR}/libcrypto.dylib"
+    )
+elseif(SYSTEM_LINUX)
+    set_target_properties(ssl PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES   "${OpenSSL_DIR}/include"
+        IMPORTED_LOCATION               "${OpenSSL_DIR}/libssl.so"
+    )
+    set_target_properties(crypto PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES   "${OpenSSL_DIR}/include"
+        IMPORTED_LOCATION               "${OpenSSL_DIR}/libcrypto.so"
+    )
+endif()
+
+# End of file

cmake/RobomongoConfigurationSummary.cmake

@@ -8,7 +8,8 @@ message("|   Qt5 Core:           ${Qt5Core_VERSION}     ${Qt5Core_DIR}")
 message("|   Qt5 Gui:            ${Qt5Gui_VERSION}     ${Qt5Gui_DIR}")
 message("|   Qt5 Widgets:        ${Qt5Widgets_VERSION}     ${Qt5Widgets_DIR}")
 message("|   Qt5 PrintSupport:   ${Qt5Widgets_VERSION}     ${Qt5PrintSupport_DIR}")
-message("|   MongoDB:            ${MongoDB_VERSION}     ${MongoDB_BUILD_DIR}")
+message("|   MongoDB:            ${MongoDB_VERSION}    ${MongoDB_BUILD_DIR}")
+message("|   OpenSSL:            ${OPENSSL_VERSION}    ${OpenSSL_DIR}")
 message("|")
 message("|-- Summary:")
 message("|")

cmake/RobomongoDefaults.cmake

@@ -52,6 +52,18 @@ elseif("${CMAKE_BUILD_TYPE}" MATCHES "MinSizeRel")
     set(BUILD_MINSIZEREL TRUE)
 endif()
 
+# Compiler checks
+# We check Clang using MATCH instead of strict equality, because as of CMake 3.0.0 the
+# CMAKE_<LANG>_COMPILER_ID value for Apple-provided Clang is AppleClang. To test
+# for both the Apple-provided Clang and the regular Clang we use MATCH.
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(COMPILER_CLANG TRUE)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "^GNU$")
+    set(COMPILER_GCC TRUE)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "^MSVC$")
+    set(COMPILER_MSVC TRUE)
+endif()
+
 # Link "groups" and "whole-archive" options
 if(SYSTEM_LINUX OR SYSTEM_FREEBSD OR SYSTEM_OPENBSD)
     set(LINK_LIBGROUP_START        -Wl,--start-group)

cmake/RobomongoInstall.cmake

@@ -56,6 +56,27 @@ install(
     FILES       "${CMAKE_BINARY_DIR}/qt.conf"
     DESTINATION "${qt_conf_dir}")
 
+# Install OpenSSL dynamic lib files
+if(SYSTEM_WINDOWS)
+    install(
+        FILES 
+        "${OpenSSL_DIR}/out32dll/ssleay32.dll"
+        "${OpenSSL_DIR}/out32dll/libeay32.dll"
+        DESTINATION ${bin_dir})
+elseif(SYSTEM_MACOSX)
+    install(
+        FILES 
+        "${OpenSSL_DIR}/libssl.1.0.0.dylib"
+        "${OpenSSL_DIR}/libcrypto.1.0.0.dylib"
+        DESTINATION ${lib_dir}/lib)
+elseif(SYSTEM_LINUX)
+    install(
+        FILES 
+        "${OpenSSL_DIR}/libssl.so.1.0.0"
+        "${OpenSSL_DIR}/libcrypto.so.1.0.0"
+        DESTINATION ${lib_dir})         
+endif()
+
 # Install binary
 install(
     TARGETS robomongo
@@ -79,7 +100,6 @@ install_icu_libs()
 if(SYSTEM_LINUX)
     install_qt_lib(XcbQpa DBus)
     install_qt_plugins(
-        QGtk2ThemePlugin
         QXcbIntegrationPlugin)
 
 elseif(SYSTEM_MACOSX)
@@ -105,4 +125,3 @@ elseif(SYSTEM_WINDOWS)
     set(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION .)
     include(InstallRequiredSystemLibraries)
 endif()
-

cmake/RobomongoTrashSymbols.cmake

@@ -10,6 +10,7 @@ elseif(SYSTEM_WINDOWS)
     # The /MP option can reduce the total time to compile the source files. This option
     # causes the compiler to create one or more copies of itself, each in a separate process.
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
+    set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} /MP")
 
     set(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES} psapi.lib bcrypt.lib Iphlpapi.lib dbghelp.lib ws2_32.lib winmm.lib version.lib")
 endif()

docs/BuildingMongoDB.md

@@ -6,7 +6,12 @@ Robomongo uses [modified version](https://github.com/paralect/robomongo-shell/tr
 Build for Mac OS X or Linux
 ---------------------------
 
-1. Clone Robomongo Shell and checkout to `roboshell-v3.2` branch:
+#### Prerequisites
+
+1. Install [Scons](http://scons.org/tag/releases.html) (2.4 or later)
+
+
+2. Clone Robomongo Shell and checkout to `roboshell-v3.2` branch:
 
   ```sh
   $ git clone https://github.com/paralect/robomongo-shell.git
@@ -14,7 +19,7 @@ Build for Mac OS X or Linux
   $ git checkout roboshell-v3.2
   ```
 
-2. Build Robomongo Shell:
+3. Build Robomongo Shell:
 
   ```sh
   $ bin/build

docs/BuildingRobomongo.md

@@ -1,28 +1,104 @@
-Building Robomongo
+Building Robomongo (Mac OS X and Linux)
 ==================
 
-#### Step 1.
+A. Prerequisites
+-------------
 
-Download and build Robomongo Shell (our fork of MongoDB). 
-Refer to [Building Robomongo Shell](BuildingMongoDB.md) document.
+1. Install CMake (3.2 or later)
+2. Install [Scons](http://scons.org/tag/releases.html) (2.4 or later)
+3. Install Qt 5.7
 
-#### Step 2.
+  ```sh
+Example installation for MAC OSX and Ubuntu:
+    Go to http://download.qt.io/archive/qt/5.7/5.7.0/
+    Download, run and install 
+      qt-opensource-mac-x64-clang-5.7.0.dmg (for MAC OSX) 
+      qt-opensource-linux-x64-5.7.0.run (for Linux)
+    After successful installation you should have 
+      /path/to/qt-5.7.0/5.7/clang_64 (for MAC OSX)
+      /path/to/qt-5.7.0/5.7/gcc_64 (for Linux)
+
+More information for installing on Ubuntu:
+https://wiki.qt.io/Install_Qt_5_on_Ubuntu
+```
+
+4. Download and Build OpenSSL (1.0.1p) - (explained below in section B)
+
+B. Building Robomongo and Dependencies
+-------------
+
+#### Step 1. Build OpenSSL (1.0.1p)
+
+Steps to build OpenSSL on MAC:
+
+  ```sh
+Download openssl-1.0.1p (ftp://ftp.openssl.org/source/old/1.0.1/openssl-1.0.1p.tar.gz)
+tar -xvzf openssl-1.0.1p.tar.gz
+cd /Users/<user>/Downloads/openssl-1.0.1p
+./Configure darwin64-x86_64-cc shared --openssldir="@rpath"
+make (or sudo make)
+mkdir lib
+cp libssl.1.0.0.dylib libcrypto.1.0.0.dylib lib/
+```
+Helper Commands
+  ```sh
+// to start fresh build
+make clean
+```
+
+
+Steps to build OpenSSL on Linux:
+
+  ```sh
+Download openssl-1.0.1p (ftp://ftp.openssl.org/source/old/1.0.1/openssl-1.0.1p.tar.gz)
+tar -xvzf openssl-1.0.1p.tar.gz
+cd /home/<user>/Downloads/openssl-1.0.1p
+./config shared
+make
+mkdir lib
+cp libssl* libcrypto* lib/
+```
+
+#### Step 2. Build Robomongo Shell (fork of MongoDB)
+
+Clone Robomongo Shell and checkout to `roboshell-v3.2` branch:
+
+  ```sh
+  $ git clone https://github.com/paralect/robomongo-shell.git
+  $ cd robomongo-shell
+  $ git checkout roboshell-v3.2
+  ```
+
+Set special environment variable `ROBOMONGO_CMAKE_PREFIX_PATH` to point to a set of 
+directories:
+
+1. Location of Qt 5 SDK  
+2. Location of Robomongo Shell  
+3. Location of OpenSSL  
+
+Separate directories by semicolon `;` (not colon):
+
+    // MAC OSX example:
+    $ export ROBOMONGO_CMAKE_PREFIX_PATH="/path/to/qt-5.7.0/5.7/clang_64;/path/to/robomongo-shell;/path/to/openssl-1.0.1p"
+    // Ubuntu example:
+    $ export ROBOMONGO_CMAKE_PREFIX_PATH="/path/to/qt-5.7.0/5.7/gcc_64;/path/to/robomongo-shell;/path/to/openssl-1.0.1p"
+
+
+Build Robomongo Shell:
+
+  ```sh
+  $ bin/build
+  ```
+
+For more information refer to [Building Robomongo Shell](BuildingMongoDB.md) 
+
+#### Step 3. Build Robomongo
 
 Download Robomongo: 
 
     $ git clone https://github.com/paralect/robomongo
     $ cd robomongo
 
-Set special environment variable `ROBOMONGO_CMAKE_PREFIX_PATH` to point to a set of 
-directories:
-
-1. Location of Qt 5 SDK
-2. Location of Robomongo Shell (built in "Step 1")
-
-Separate directories by semicolon `;` (not colon):
-
-    $ export ROBOMONGO_CMAKE_PREFIX_PATH="/path/to/qt-5.5/5.5/clang_64;/path/to/robomongo-shell"
-    
 Run configuration step:
     
     $ bin/configure 
@@ -30,14 +106,14 @@ Run configuration step:
 And finally, build Robomongo:
     
     $ bin/build 
-    
-<br>    
-## Helper commands
 
-Execute just built Robomongo:
+To run robomongo:
 
     $ bin/run
     
+
+**Helper commands**
+    
 Clean build files (in order to start build from scratch):
 
     $ bin/clean

docs/BuildingRobomongoOnWindows.md

@@ -1,7 +1,7 @@
-Building Robomongo for Windows
+Building Robomongo (Windows)
 ==============================
 
-Prerequisites
+A. Prerequisites
 -------------
 
 #### 0. Git
@@ -64,25 +64,70 @@ Prerequisites
  command will be available from Command Prompt. For this set "Add CMake to the system
  PATH for current user" in the installer wizard page. 
    
-#### 5. Qt 5.5
+#### 5. Qt 5.7
 
  Download Qt from http://www.qt.io/download-open-source/ (we use Qt Online installer)
    
  When installing Qt, only one component is required by Robomongo: 
    
-    Qt 5.5 
+    Qt 5.7 
       [x] msvc2013 64-bit.
     
  This components contains prebuilt 64-bit binaries for Visual Studio 2013. 
    
  You may uncheck all other components to download as little as possible. 
 
+#### 6. OpenSSL (1.0.1p)
+Download openssl-1.0.1p (ftp://ftp.openssl.org/source/old/1.0.1/openssl-1.0.1p.tar.gz)
+  
+  
 
+B. Building Robomongo and Dependencies
+-------------
 
-## Build Robomongo Shell (fork of MongoDB)
+#### 1. Build OpenSSL (1.0.1p)
+
+Steps to build OpenSSL on windows:
+  ```sh
+Open Visual Studio tool x64 Cross Tools Command prompt
+cd to the directory where you have openssl sources cd c:\myPath\openssl
+perl Configure VC-WIN64A
+ms\do_win64a
+nmake -f ms\ntdll.mak
+```
+
+**Check Point:**
+After successful build, newly created sub directory out32dll should contain dynamic lib files libeay32.lib (and libeay32.dll) and ssleay32.lib (and ssleay32.dll); and associated include files will be in newly created folder "inc32".
+
+Helper Commands:
+  ```sh
+// clean to start fresh build
+nmake -f ms\ntdll.mak clean
+```
+
+Refer to OpenSSL documentation for more information:  
+https://wiki.openssl.org/index.php/Compilation_and_Installation#W64
+
+#### 2. Build Robomongo Shell (fork of MongoDB)
+
+Clone Robomongo Shell and checkout to roboshell-v3.2 branch:
+
+  ```sh
+  $ git clone https://github.com/paralect/robomongo-shell.git
+  $ cd robomongo-shell
+  $ git checkout roboshell-v3.2
+  ```
+
+Set environment variable `ROBOMONGO_CMAKE_PREFIX_PATH`, required by Robomongo-Shell and Robomongo build scripts, needs to be set according to the following directories:
+
+1. Location of Qt SDK
+2. Location of Robomongo Shell
+3. Location of OpenSSL
+
+Separate directories by semicolon `;` (not colon). You can do this in Command Prompt:
+
+    > setx ROBOMONGO_CMAKE_PREFIX_PATH "d:\Qt-5\5.7\msvc2013_64;d:\Projects\robomongo-shell;c:\myPath\openssl-1.0.1p"
 
-Refer to MongoDB documentation for additional information:
-https://docs.mongodb.org/manual/contributors/tutorial/build-mongodb-from-source/#windows-specific-instructions
 
 Open VS2013 x64 Native Tools Command Prompt and navigate to `robomongo-shell` folder.
 
@@ -96,20 +141,19 @@ Clean build files:
 
     > bin\clean
 
+Refer to MongoDB documentation for additional information:
+https://docs.mongodb.org/manual/contributors/tutorial/build-mongodb-from-source/#windows-specific-instructions
 
-## Build Robomongo   
 
-Set special environment variable `ROBOMONGO_CMAKE_PREFIX_PATH` to point to set of 
-directories:
+#### 3. Build Robomongo   
 
-1. Location of Qt SDK
-2. Location of Robomongo Shell
+Clone Robomongo:
 
-Separate directories by semicolon `;` (not colon). You can do this in Command Prompt:
-
-    > setx ROBOMONGO_CMAKE_PREFIX_PATH "d:\Qt-5\5.5\msvc2013_64;d:\Projects\robomongo-shell"
-    
-Reopen your Command Prompt to make this variable available.
+  ```sh
+  $ git clone https://github.com/paralect/robomongo.git
+  ```
+  
+Open VS2013 x64 Native Tools Command Prompt and navigate to `robomongo` folder.
  
 Run configuration step:
     
@@ -118,15 +162,23 @@ Run configuration step:
 And finally, build Robomongo:
     
     > bin\build 
-    
-    
-#### Helper commands
+ 
+
+**Run Robomongo**
+
+Install Robomongo to `build\Release\install` folder:
+
+    > bin\install
+   
+And run Robomongo
+
+    > \robomongo\build\Release\install\Robomongo.exe
+
+**Helper commands**
     
 Clean build files (in order to start build from scratch):
 
     > bin\clean
     
-Install Robomongo to `build\Release\install` folder:
 
-    > bin\install
    

src/robomongo/CMakeLists.txt

@@ -5,6 +5,10 @@ set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
 set(CMAKE_AUTOUIC ON)
 
+#set(sanitize "-fsanitize=address")
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${sanitize}")
+#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${sanitize}")
+
 set(SOURCES
 
     # Isolated Scope #1
@@ -62,6 +66,7 @@ set(SOURCES
     gui/dialogs/ConnectionDialog.cpp
     gui/dialogs/CopyCollectionDialog.cpp
     gui/widgets/workarea/IndicatorLabel.cpp
+    gui/dialogs/CreateCollectionDialog.cpp
     gui/dialogs/CreateDatabaseDialog.cpp
     gui/dialogs/CreateUserDialog.cpp
     gui/utils/ComboBoxUtils.cpp
@@ -81,6 +86,7 @@ set(SOURCES
     # Isolated scope #6
     gui/widgets/explorer/ExplorerCollectionTreeItem.cpp
     gui/widgets/explorer/ExplorerTreeItem.cpp
+    gui/widgets/explorer/ExplorerReplicaSetTreeItem.cpp
     gui/widgets/explorer/ExplorerDatabaseTreeItem.cpp
     gui/widgets/explorer/ExplorerDatabaseCategoryTreeItem.cpp
     gui/widgets/explorer/ExplorerUserTreeItem.cpp
@@ -117,7 +123,10 @@ set(SOURCES
     gui/MainWindow.cpp
 
     gui/dialogs/SSHTunnelTab.cpp
+    gui/dialogs/SSLTab.cpp
     core/settings/SshSettings.cpp
+    core/settings/SslSettings.cpp
+	core/settings/ReplicaSetSettings.cpp
     core/mongodb/SshTunnelWorker.cpp
 
     gui/resources/gui.qrc

src/robomongo/app/main.cpp

@@ -7,14 +7,14 @@
 // Header "mongo/platform/basic" is required by "sock.h" under Windows
 #include <mongo/platform/basic.h>
 #include <mongo/util/net/sock.h>
-
 #include <mongo/base/initializer.h>
+#include <mongo/util/net/ssl_options.h>
 
 #include "robomongo/gui/MainWindow.h"
 #include "robomongo/gui/AppStyle.h"
-
 #include "robomongo/ssh/ssh.h"
 
+
 int main(int argc, char *argv[], char** envp)
 {
     if (rbm_ssh_init()) {
@@ -29,6 +29,12 @@ int main(int argc, char *argv[], char** envp)
     // Support for IPv6 is disabled by default. Enable it.
     mongo::enableIPv6(true);
 
+    // Perform SSL-enabled mongo initialization
+    mongo::sslGlobalParams.sslMode.store(mongo::SSLParams::SSLMode_allowSSL);
+
+    // Cross Platform High DPI support - Qt 5.7
+    QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+
     // Initialization routine for MongoDB shell
     mongo::runGlobalInitializersOrDie(argc, argv, envp);
 
@@ -39,30 +45,21 @@ int main(int argc, char *argv[], char** envp)
     // This can cause a conflict when using POSIX functions, for instance, when
     // converting between data types such as floats and strings, since the notation
     // may differ between locales. To get around this problem, call the POSIX
-    // function setlocale(LC_NUMERIC,"C") right after initializing QApplication or
+    // function setlocale(LC_NUMERIC, "C") right after initializing QApplication or
     // QCoreApplication to reset the locale that is used for number formatting to "C"-locale.
     // (http://doc.qt.io/qt-5/qcoreapplication.html#locale-settings)
     setlocale(LC_NUMERIC, "C");
 
+#ifdef Q_OS_MAC
+    app.setAttribute(Qt::AA_UseHighDpiPixmaps);
+#endif
+
     // Init GUI style
     Robomongo::AppStyleUtils::initStyle();
 
     // Application main window
-    Robomongo::MainWindow win;
-
-    // Resize main window. We are trying to keep it "almost" maximized.
-    QRect screenGeometry = QApplication::desktop()->availableGeometry();
-    int horizontalMargin = (int)(screenGeometry.width() * 0.1);
-    int verticalMargin = (int)(screenGeometry.height() * 0.1);
-    int width = screenGeometry.width() - horizontalMargin;
-    int height = screenGeometry.height() - verticalMargin;
-    win.resize(QSize(width, height));
-
-    // Center main window
-    int x = (screenGeometry.width() - win.width()) / 2;
-    int y = (screenGeometry.height() - win.height()) / 2;
-    win.move(x, y);
-    win.show();
+    Robomongo::MainWindow mainWindow;
+    mainWindow.show();
 
     int rc = app.exec();
     rbm_ssh_cleanup();

src/robomongo/app/main_test.cpp

@@ -33,12 +33,19 @@ void precisionAssert(const std::string &text, double d) {
     std::stringstream s;
     s.precision(std::numeric_limits<double>::digits10);
     s << d;
+    if (d == (long long)d)
+        s << ".0";
     std::cout << "Checking " << text << " - ";
     assert(text == s.str());
     std::cout << "Correct. " << std::endl;
 }
 
 void testPrecision() {
+    precisionAssert("-9.987654321", -9.987654321);
+    precisionAssert("-1.0", -1.0);
+    precisionAssert("-0.0", -0.0);
+    precisionAssert("0.0", 0.0);
+    precisionAssert("9.0", 9.0);
     precisionAssert("9.8", 9.8);
     precisionAssert("9.9", 9.9);
     precisionAssert("9.98", 9.98);

src/robomongo/core/Core.h

@@ -30,4 +30,18 @@ namespace Robomongo
 
     class MongoDocument;
     typedef boost::shared_ptr<MongoDocument> MongoDocumentPtr;
+
+    enum ConnectionType {
+        // This type of connection is shown in Explorer and also
+        // opens SSH tunnel for Secondary connections (if needed)
+        ConnectionPrimary      = 0,
+
+        // Never shown in Explorer and uses SSH tunnel from
+        // Primary connection (if needed)
+        ConnectionSecondary    = 1,
+
+        // The same as Primary, but is specifically for testing
+        // connections.
+        ConnectionTest         = 2
+    };
 }

src/robomongo/core/Enums.cpp

@@ -10,9 +10,9 @@ namespace
     template<typename type, int size>
     inline type findTypeInArray(const char *(&arr)[size], const char *text)
     {
-        for (int i=0; i < size;++i )
+        for (int i = 0; i < size; ++i )
         {
-            if (strcmp(text,arr[i])==0)
+            if (strcmp(text, arr[i]) == 0)
             {
                 return static_cast<type>(i);
             }

src/robomongo/core/HexUtils.cpp

@@ -36,7 +36,7 @@ namespace Robomongo
             char *data = new char[bytes];
 
             const char *p = s.c_str();
-            for( size_t i = 0; i < bytes; i++ ) {
+            for (size_t i = 0; i < bytes; i++) {
                 data[i] = mongo::fromHex(p);
                 p += 2;
             }
@@ -159,7 +159,7 @@ namespace Robomongo
             mongo::BinDataType binType = element.binDataType();
 
             if (binType != mongo::newUUID && binType != mongo::bdtUUID)
-                throw new std::invalid_argument("Binary subtype should be 3 (bdtUUID) or 4 (newUUID)");
+                throw std::invalid_argument("Binary subtype should be 3 (bdtUUID) or 4 (newUUID)");
 
             int len;
             const char *data = element.binData(len);

src/robomongo/core/domain/App.cpp

@@ -1,11 +1,13 @@
 #include "robomongo/core/domain/App.h"
 #include <QHash>
+#include <QInputDialog>
 
 #include "robomongo/core/domain/MongoServer.h"
 #include "robomongo/core/domain/MongoShell.h"
 #include "robomongo/core/domain/MongoCollection.h"
 #include "robomongo/core/settings/ConnectionSettings.h"
 #include "robomongo/core/settings/SshSettings.h"
+#include "robomongo/core/settings/SslSettings.h"
 #include "robomongo/core/mongodb/SshTunnelWorker.h"
 #include "robomongo/core/EventBus.h"
 #include "robomongo/core/utils/QtUtils.h"
@@ -33,7 +35,7 @@ namespace Robomongo
     }
 
     App::App(EventBus *const bus) : QObject(),
-        _bus(bus) {
+        _bus(bus), _lastServerHandle(0) {
         _bus->subscribe(this, EstablishSshConnectionResponse::Type);
         _bus->subscribe(this, ListenSshConnectionResponse::Type);
         _bus->subscribe(this, LogEvent::Type);
@@ -45,19 +47,74 @@ namespace Robomongo
         std::for_each(_servers.begin(), _servers.end(), stdutils::default_delete<MongoServer*>());
     }
 
+    bool App::openServer(ConnectionSettings *connection, ConnectionType type) {
+
+        SshSettings *ssh = connection->sshSettings();
+
+        if (ssh->enabled() && ssh->askPassword() &&
+            (type == ConnectionPrimary || type == ConnectionTest)) {
+            bool ok = false;
+
+            bool isByKey = ssh->authMethod() == "publickey";
+            std::string passText = isByKey ? "passphrase" : "password";
+
+            std::stringstream s;
+            s << "In order to continue, please provide the " << passText;
+
+            if (isByKey)
+                s << " for the key file";
+
+            s << "." << std::endl << std::endl;
+
+            if (ssh->authMethod() == "publickey")
+                s << "Private Key:  " << ssh->privateKeyFile() << std::endl;
+
+            s << "Server: " << ssh->host() << std::endl;
+            s << "User: " << ssh->userName() << std::endl;
+
+
+            s << std::endl << "Enter your " << passText << " that will never be stored:";
+
+            QString userInput = QInputDialog::getText(NULL, tr("SSH Authentication"),
+                QtUtils::toQString(s.str()),
+                QLineEdit::Password, "", &ok);
+
+            if (!ok)
+                return false;
+
+            ssh->setAskedPassword(QtUtils::toStdString(userInput));
+        }
+
+        SslSettings *sslSettings = connection->sslSettings();
+
+        if (sslSettings->sslEnabled() && sslSettings->usePemFile() && sslSettings->askPassphrase() 
+            && (type == ConnectionPrimary || type == ConnectionTest)) 
+        {
+            if (!askSslPassphrasePromptDialog(connection))
+            {
+                return false;
+            }
+        }
+
+        openServerInternal(connection, type);
+        return true;
+    }
+
     /**
      * Creates and opens new server connection.
      * @param connection: ConnectionSettings, that will be owned by MongoServer.
      * @param visible: should this server be visible in UI (explorer) or not.
      */
-    MongoServer *App::openServer(ConnectionSettings *connection, bool visible) {
-        if (visible)
+    MongoServer *App::openServerInternal(ConnectionSettings const* connection, ConnectionType type) {
+        ++_lastServerHandle;
+
+        if (type == ConnectionPrimary)
             _bus->publish(new ConnectingEvent(this));
 
-        // When connection is not "visible" or do not have
+        // When connection is SECONDARY or do not have
         // ssh settings enabled, continue without SSH Tunnel
-        if (!visible || !connection->sshSettings()->enabled()) {
-            return continueOpenServer(connection, visible);
+        if (type == ConnectionSecondary || !connection->sshSettings()->enabled()) {
+            return continueOpenServer(_lastServerHandle, connection, type);
         }
 
         // Open SSH channel and only after that open connection
@@ -67,7 +124,7 @@ namespace Robomongo
 
         ConnectionSettings* settingsCopy = connection->clone();
         SshTunnelWorker* sshWorker = new SshTunnelWorker(settingsCopy);
-        _bus->send(sshWorker, new EstablishSshConnectionRequest(this, sshWorker, settingsCopy, visible));
+        _bus->send(sshWorker, new EstablishSshConnectionRequest(this, _lastServerHandle, sshWorker, settingsCopy, type));
         return NULL;
     }
 
@@ -80,43 +137,46 @@ namespace Robomongo
         _servers.erase(std::remove_if(_servers.begin(), _servers.end(), stdutils::RemoveIfFound<MongoServer*>(server)), _servers.end());
     }
 
-    MongoShell *App::openShell(MongoCollection *collection,const QString &filePathToSave)
+    void App::openShell(MongoCollection *collection, const QString &filePathToSave)
     {
         ConnectionSettings *connection = collection->database()->server()->connectionRecord();
         connection->setDefaultDatabase(collection->database()->name());
         QString script = detail::buildCollectionQuery(collection->name(), "find({})");
-        return openShell(connection, ScriptInfo(script, true, CursorPosition(0, -2), QtUtils::toQString(collection->database()->name()),filePathToSave));
+        openShell(connection, ScriptInfo(script, true, CursorPosition(0, -2), QtUtils::toQString(collection->database()->name()), filePathToSave));
     }
 
-    MongoShell *App::openShell(MongoServer *server,const QString &script, const std::string &dbName,
+    void App::openShell(MongoServer *server, const QString &script, const std::string &dbName,
                                bool execute, const QString &shellName,
-                               const CursorPosition &cursorPosition,const QString &filePathToSave)
+                               const CursorPosition &cursorPosition, const QString &filePathToSave)
     {
         ConnectionSettings *connection = server->connectionRecord();
 
         if (!dbName.empty())
             connection->setDefaultDatabase(dbName);
 
-        return openShell(connection, ScriptInfo(script, execute, cursorPosition, shellName,filePathToSave));
+        openShell(connection, ScriptInfo(script, execute, cursorPosition, shellName, filePathToSave));
     }
 
-    MongoShell *App::openShell(MongoDatabase *database, const QString &script,
+    void App::openShell(MongoDatabase *database, const QString &script,
                                bool execute, const QString &shellName,
-                               const CursorPosition &cursorPosition,const QString &filePathToSave)
+                               const CursorPosition &cursorPosition, const QString &filePathToSave)
     {
         ConnectionSettings *connection = database->server()->connectionRecord();
         connection->setDefaultDatabase(database->name());
-        return openShell(connection, ScriptInfo(script, execute, cursorPosition, shellName,filePathToSave));
+        openShell(connection, ScriptInfo(script, execute, cursorPosition, shellName, filePathToSave));
     }
 
-    MongoShell *App::openShell(ConnectionSettings *connection, const ScriptInfo &scriptInfo)
+    void App::openShell(ConnectionSettings const* connection, const ScriptInfo &scriptInfo)
     {
-        MongoServer *server = openServer(connection, false);
-        MongoShell *shell = new MongoShell(server,scriptInfo);
+        MongoServer *server = openServerInternal(connection, ConnectionSecondary);
+        if (!server)
+            return;
+
+        MongoShell *shell = new MongoShell(server, scriptInfo);
         _shells.push_back(shell);
         _bus->publish(new OpeningShellEvent(this, shell));
         shell->execute();
-        return shell;
+        return;
     }
 
     /**
@@ -126,7 +186,7 @@ namespace Robomongo
     void App::closeShell(MongoShell *shell)
     {
         // Do nothing, if this shell not owned by this App.
-        MongoShellsContainerType::iterator it = std::find_if(_shells.begin(),_shells.end(),std::bind1st(std::equal_to<MongoShell *>(),shell));
+        MongoShellsContainerType::iterator it = std::find_if(_shells.begin(), _shells.end(), std::bind1st(std::equal_to<MongoShell *>(), shell));
         if (it == _shells.end())
             return;
 
@@ -135,16 +195,17 @@ namespace Robomongo
         delete shell;
     }
 
-    MongoServer* App::continueOpenServer(ConnectionSettings *connection, bool visible, int localport) {
+    MongoServer *App::continueOpenServer(int serverHandle, ConnectionSettings const* connection, ConnectionType type, int localport) {
         ConnectionSettings* settings = connection->clone();
 
         // Modify connection settings when SSH tunnel is used
-        if (visible && settings->sshSettings()->enabled()) {
+        if ((type == ConnectionPrimary || type == ConnectionTest)
+            && settings->sshSettings()->enabled()) {
             settings->setServerHost("127.0.0.1");
             settings->setServerPort(localport);
         }
 
-        MongoServer *server = new MongoServer(settings, visible);
+        MongoServer *server = new MongoServer(serverHandle, settings, type);
         _servers.push_back(server);
 
         server->runWorkerThread();
@@ -156,36 +217,71 @@ namespace Robomongo
 
     void App::handle(EstablishSshConnectionResponse *event) {
         if (event->isError()) {
-            _bus->publish(new ConnectionFailedEvent(this, event->error().errorMessage()));
+            _bus->publish(new ConnectionFailedEvent(
+                this, event->serverHandle, event->connectionType, event->error().errorMessage(),
+                ConnectionFailedEvent::SshConnection));
             return;
         }
 
         LOG_MSG(QString("SSH tunnel created successfully"), mongo::logger::LogSeverity::Info());
 
-        _bus->send(event->worker, new ListenSshConnectionRequest(this));
-        continueOpenServer(event->settings, event->visible, event->localport);
-
-        // record event->worker and delete when needed
+        continueOpenServer(event->serverHandle, event->settings, event->connectionType, event->localport);
+        _bus->send(event->worker, new ListenSshConnectionRequest(this, event->serverHandle, event->connectionType));
     }
 
     void App::handle(LogEvent *event) {
-        if (event->level == LogEvent::ERROR) {
+        if (event->level == LogEvent::RBM_ERROR) {
             LOG_MSG(event->message, mongo::logger::LogSeverity::Error());
-        } else if (event->level == LogEvent::WARN) {
+        } else if (event->level == LogEvent::RBM_WARN) {
             LOG_MSG(event->message, mongo::logger::LogSeverity::Warning());
-        } else if (event->level == LogEvent::INFO) {
+        } else if (event->level == LogEvent::RBM_INFO) {
             LOG_MSG(event->message, mongo::logger::LogSeverity::Info());
-        } else if (event->level == LogEvent::DEBUG) {
+        } else if (event->level == LogEvent::RBM_DEBUG) {
             LOG_MSG(event->message, mongo::logger::LogSeverity::Log());
         }
     }
 
     void App::handle(ListenSshConnectionResponse *event) {
         if (event->isError()) {
-            _bus->publish(new ConnectionFailedEvent(this, event->error().errorMessage()));
+            _bus->publish(new ConnectionFailedEvent(this, event->serverHandle, event->connectionType, event->error().errorMessage(),
+                ConnectionFailedEvent::SshChannel));
             return;
         }
 
         LOG_MSG(QString("SSH tunnel closed."), mongo::logger::LogSeverity::Error());
     }
+
+    void App::fireConnectionFailedEvent(int serverHandle, ConnectionType type, std::string errormsg,
+                                        ConnectionFailedEvent::Reason reason) {
+        _bus->publish(new ConnectionFailedEvent(this, serverHandle, type, errormsg, reason));
+    }
+
+
+    bool App::askSslPassphrasePromptDialog(ConnectionSettings *connSettings) const
+    {
+        auto sslSettings = connSettings->sslSettings();
+        bool ok = false;
+
+        std::stringstream s;
+        s << "In order to continue, please provide the passphrase";
+        s << "." << std::endl << std::endl;
+
+        s << "Server: " << connSettings->serverHost() << ":" << connSettings->serverPort() << std::endl;
+        s << "PEM file: " << sslSettings->pemKeyFile() << std::endl;
+
+        s << std::endl << "Enter your PEM key passphrase (will never be stored):";
+
+        QString userInput = QInputDialog::getText(NULL, tr("SSL Authentication"),
+            QtUtils::toQString(s.str()),
+            QLineEdit::Password, "", &ok);
+
+        if (!ok)
+        {
+            return false;
+        }
+
+        sslSettings->setPemPassPhrase(QtUtils::toStdString(userInput));
+        return ok;
+    }
+
 }

src/robomongo/core/domain/App.h

@@ -47,8 +47,9 @@ namespace Robomongo
          * @brief Creates and opens new server connection.
          * @param connection: ConnectionSettings, that will be owned by MongoServer.
          * @param visible: should this server be visible in UI (explorer) or not.
+         * @return Succeeded or not
          */
-        MongoServer *openServer(ConnectionSettings *connection, bool visible);
+        bool openServer(ConnectionSettings *connection, ConnectionType type);
 
         /**
          * @brief Closes MongoServer connection and frees all resources, owned
@@ -59,18 +60,18 @@ namespace Robomongo
         /**
          * @brief Open new shell based on specified collection
          */
-        MongoShell *openShell(MongoCollection *collection,const QString &filePathToSave=QString());
+        void openShell(MongoCollection *collection, const QString &filePathToSave = QString());
 
-        MongoShell *openShell(MongoServer *server, const QString &script, const std::string &dbName = std::string(),
+        void openShell(MongoServer *server, const QString &script, const std::string &dbName = std::string(),
                               bool execute = true, const QString &shellName = QString(),
                               const CursorPosition &cursorPosition = CursorPosition(), const QString &file = QString());
 
-        MongoShell *openShell(MongoDatabase *database, const QString &script,
+        void openShell(MongoDatabase *database, const QString &script,
                               bool execute = true, const QString &shellName = QString(),
                               const CursorPosition &cursorPosition = CursorPosition(), const QString &filePathToSave = QString());
 
-        MongoShell *openShell(ConnectionSettings *connection, const ScriptInfo &scriptInfo);
-        MongoServersContainerType getServers() const {return _servers; };
+        void openShell(ConnectionSettings const* connection, const ScriptInfo &scriptInfo);
+        MongoServersContainerType getServers() const { return _servers; };
 
         /**
          * @brief Closes MongoShell and frees all resources, owned by specified MongoShell.
@@ -78,13 +79,25 @@ namespace Robomongo
          */
         void closeShell(MongoShell *shell);
 
+        void fireConnectionFailedEvent(int serverHandle, ConnectionType type, std::string errormsg, ConnectionFailedEvent::Reason reason);
+
+        int getLastServerHandle() const { return _lastServerHandle; };
+
     public Q_SLOTS:
         void handle(EstablishSshConnectionResponse *event);
         void handle(ListenSshConnectionResponse *event);
         void handle(LogEvent *event);
 
     private:
-        MongoServer* continueOpenServer(ConnectionSettings *connection, bool visible, int localport = 0);
+        MongoServer *openServerInternal(ConnectionSettings const* connection, ConnectionType type);
+        MongoServer *continueOpenServer(int serverHandle, ConnectionSettings const *connection, ConnectionType type, int localport = 0);
+
+        /**
+        * @brief Create prompt dialog to enter SSL PEM key passphrase and save passphrase into SSL settings
+        * @param connection Pointer to active connection settings
+        * @return true on success, false otherwise
+        */
+        bool askSslPassphrasePromptDialog(ConnectionSettings *connSettings) const;
 
         /**
          * MongoServers, owned by this App.
@@ -97,5 +110,9 @@ namespace Robomongo
         MongoShellsContainerType _shells;
 
         EventBus *const _bus;
+
+        // Increase monotonically when new MongoServer is created
+        // Never decreases.
+        int _lastServerHandle;
     };
 }

src/robomongo/core/domain/MongoDatabase.cpp

@@ -15,6 +15,13 @@ namespace Robomongo
     R_REGISTER_EVENT(MongoDatabaseFunctionsLoadingEvent)
     R_REGISTER_EVENT(MongoDatabaseCollectionsLoadingEvent)
 
+    const std::string MongoDatabase::StorageEngineType::WIRED_TIGER = "wiredTiger";
+    const std::string MongoDatabase::StorageEngineType::MMAPV1      = "mmapv1";
+ 
+    const float MongoDatabase::DBVersion::MONGODB_2_6 = 2.6f;
+    const float MongoDatabase::DBVersion::MONGODB_3_0 = 3.0f;
+    const float MongoDatabase::DBVersion::MONGODB_3_2 = 3.2f;
+
     MongoDatabase::MongoDatabase(MongoServer *server, const std::string &name) :
         QObject(),
         _system(name == "admin" || name == "local"),
@@ -44,9 +51,11 @@ namespace Robomongo
         _bus->publish(new MongoDatabaseFunctionsLoadingEvent(this));
         _bus->send(_server->client(), new LoadFunctionsRequest(this, _name));
     }
-    void MongoDatabase::createCollection(const std::string &collection)
+
+    void MongoDatabase::createCollection(const std::string &collection, long long size, bool capped, int maxDocNum, const mongo::BSONObj& extraOptions)
     {
-        _bus->send(_server->client(), new CreateCollectionRequest(this, MongoNamespace(_name, collection)));
+        _bus->send(_server->client(), 
+            new CreateCollectionRequest(this, MongoNamespace(_name, collection), extraOptions, size, capped, maxDocNum));
     }
 
     void MongoDatabase::dropCollection(const std::string &collection)
@@ -149,4 +158,19 @@ namespace Robomongo
     {
         _collections.push_back(collection);
     }
+
+    void MongoDatabase::handle(CreateCollectionResponse *event) {
+        genericResponseHandler(event, "Failed to create collection.");
+    }
+
+    void MongoDatabase::handle(DropCollectionResponse *event) {
+        genericResponseHandler(event, "Failed to drop collection.");
+    }
+
+    void MongoDatabase::genericResponseHandler(Event *event, const std::string &userFriendlyMessage) {
+        if (!event->isError())
+            return;
+
+        _bus->publish(new OperationFailedEvent(this, event->error().errorMessage(), userFriendlyMessage));
+    }
 }

src/robomongo/core/domain/MongoDatabase.h

@@ -18,6 +18,25 @@ namespace Robomongo
         Q_OBJECT
 
     public:
+        /**
+        * @brief Database storage engine type
+        */
+        struct StorageEngineType
+        {
+            static const std::string WIRED_TIGER;
+            static const std::string MMAPV1;
+        };
+
+        /**
+        * @brief MongoDB version
+        */
+        struct DBVersion 
+        {
+            static const float MONGODB_2_6;
+            static const float MONGODB_3_0;
+            static const float MONGODB_3_2;
+        };
+
         /**
          * @brief MongoDatabase
          * @param server: pointer to parent MongoServer
@@ -37,7 +56,7 @@ namespace Robomongo
 
         void loadFunctions();
 
-        void createCollection(const std::string &collection);
+        void createCollection(const std::string &collection, long long size, bool capped, int maxDocNum, const mongo::BSONObj& extraOptions);
         void dropCollection(const std::string &collection);
         void renameCollection(const std::string &collection, const std::string &newCollection);
         void duplicateCollection(const std::string &collection, const std::string &newCollection);
@@ -65,10 +84,13 @@ namespace Robomongo
         void handle(LoadUsersResponse *event);
         void handle(LoadFunctionsResponse *event);
         void handle(CreateUserResponse *event);
+        void handle(CreateCollectionResponse *event);
+        void handle(DropCollectionResponse *event);
 
     private:
         void clearCollections();
         void addCollection(MongoCollection *collection);
+        void genericResponseHandler(Event *event, const std::string &userFriendlyMessage);
 
     private:
         MongoServer *_server;

src/robomongo/core/domain/MongoDocument.cpp

@@ -38,7 +38,7 @@ namespace Robomongo
     std::vector<MongoDocumentPtr> MongoDocument::fromBsonObj(const std::vector<mongo::BSONObj> &bsonObjs)
     {
         std::vector<MongoDocumentPtr> list;
-        for (std::vector<mongo::BSONObj>::const_iterator it=bsonObjs.begin(); it!=bsonObjs.end(); ++it) {
+        for (std::vector<mongo::BSONObj>::const_iterator it = bsonObjs.begin(); it != bsonObjs.end(); ++it) {
             list.push_back(fromBsonObj(*it));
         }
 

src/robomongo/core/domain/MongoFunction.cpp

@@ -6,7 +6,7 @@ namespace Robomongo
 {
     MongoFunction::MongoFunction(const mongo::BSONObj &obj)
     {
-        _name = BsonUtils::getField<mongo::String>(obj,"_id");
+        _name = BsonUtils::getField<mongo::String>(obj, "_id");
         _code = obj.getField("value")._asCode();
     }
 

src/robomongo/core/domain/MongoQueryInfo.cpp

@@ -9,8 +9,8 @@ namespace Robomongo
         std::string prepareServerAddress(const std::string &address)
         {
             size_t pos = address.find_first_of("{");
-            if (pos!=std::string::npos){
-                return address.substr(0,pos);
+            if (pos != std::string::npos) {
+                return address.substr(0, pos);
             }       
             return address;
         }
@@ -20,7 +20,7 @@ namespace Robomongo
 
     CollectionInfo::CollectionInfo(const std::string &server, const std::string &database, const std::string &collection)
         :_serverAddress(server),
-        _ns(database,collection)
+        _ns(database, collection)
     {}
 
     bool CollectionInfo::isValid() const

src/robomongo/core/domain/MongoServer.cpp

@@ -7,19 +7,22 @@
 #include "robomongo/core/mongodb/MongoWorker.h"
 #include "robomongo/core/mongodb/SshTunnelWorker.h"
 #include "robomongo/core/AppRegistry.h"
+#include "robomongo/core/domain/App.h"
 #include "robomongo/core/EventBus.h"
 #include "robomongo/core/utils/QtUtils.h"
 
 namespace Robomongo {
     R_REGISTER_EVENT(MongoServerLoadingDatabasesEvent)
 
-    MongoServer::MongoServer(ConnectionSettings *settings, bool visible) : QObject(),
+    MongoServer::MongoServer(int handle, ConnectionSettings *settings, ConnectionType connectionType) : QObject(),
         _version(0.0f),
-        _visible(visible),
+        _connectionType(connectionType),
         _client(NULL),
         _isConnected(false),
         _settings(settings),
-        _bus(AppRegistry::instance().bus()) { }
+        _handle(handle),
+        _bus(AppRegistry::instance().bus()),
+        _app(AppRegistry::instance().app()) { }
 
     bool MongoServer::isConnected() const {
         return _isConnected;
@@ -49,7 +52,7 @@ namespace Robomongo {
      * @throws MongoException, if fails
      */
     void MongoServer::tryConnect() {
-        _bus->send(_client, new EstablishConnectionRequest(this));
+        _bus->send(_client, new EstablishConnectionRequest(this, _connectionType));
     }
 
     QStringList MongoServer::getDatabasesNames() const {
@@ -62,7 +65,7 @@ namespace Robomongo {
     }
 
     void MongoServer::createDatabase(const std::string &dbName) {
-        _bus->send(_client,new CreateDatabaseRequest(this, dbName));
+        _bus->send(_client, new CreateDatabaseRequest(this, dbName));
     }
 
     MongoDatabase *MongoServer::findDatabaseByName(const std::string &dbName) const {
@@ -76,7 +79,7 @@ namespace Robomongo {
     }
 
     void MongoServer::dropDatabase(const std::string &dbName) {
-        _bus->send(_client,new DropDatabaseRequest(this, dbName));
+        _bus->send(_client, new DropDatabaseRequest(this, dbName));
     }
 
     void MongoServer::insertDocuments(const std::vector<mongo::BSONObj> &objCont,
@@ -87,12 +90,12 @@ namespace Robomongo {
     }
 
     void MongoServer::insertDocument(const mongo::BSONObj &obj, const MongoNamespace &ns) {
-        _bus->send(_client,new InsertDocumentRequest(this, obj, ns));
+        _bus->send(_client, new InsertDocumentRequest(this, obj, ns));
     }
 
     void MongoServer::saveDocuments(const std::vector<mongo::BSONObj> &objCont, const MongoNamespace &ns) {
         for (std::vector<mongo::BSONObj>::const_iterator it = objCont.begin(); it != objCont.end(); it++) {
-            saveDocument(*it,ns);
+            saveDocument(*it, ns);
         }
     }
 
@@ -122,26 +125,57 @@ namespace Robomongo {
         if (event->isError()) {
             _isConnected = false;
 
-            std::stringstream ss;
-            ss << "Cannot connect to the MongoDB at " << connectionRecord()->getFullAddress()
-               << ".\n\nError:\n" << event->error().errorMessage();
+            std::stringstream ss("Unknown error");
+            auto eventErrorReason = event->errorReason;
+            if (EstablishConnectionResponse::ErrorReason::MongoSslConnection == eventErrorReason)
+            {
+                auto reason = ConnectionFailedEvent::SslConnection;
+                ss.clear();
+                ss << "Cannot connect to the MongoDB at " << connectionRecord()->getFullAddress()
+                    << ".\n\nError:\n" << "SSL connection failure: " << event->error().errorMessage();
+                _app->fireConnectionFailedEvent(_handle, _connectionType, ss.str(), reason);
+            }
+            else
+            {
+                auto reason = (EstablishConnectionResponse::ErrorReason::MongoAuth == eventErrorReason) ?
+                    ConnectionFailedEvent::MongoAuth : ConnectionFailedEvent::MongoConnection;
+                ss.clear();
+                ss << "Cannot connect to the MongoDB at " << connectionRecord()->getFullAddress()
+                    << ".\n\nError:\n" << event->error().errorMessage();
+                _app->fireConnectionFailedEvent(_handle, _connectionType, ss.str(), reason);
+            }
+
+            // When connection cannot be established, we should cleanup this instance of MongoServer if it wasn't
+            // shown in UI (i.e. it is not a Secondary connection that is used for shells tab)
+            if (_connectionType == ConnectionPrimary || _connectionType == ConnectionTest)
+            {
+                _app->closeServer(this);
+            }
 
-            _bus->publish(new ConnectionFailedEvent(this, ss.str()));
             return;
         }
 
+        // Save various information after successful connection
         const ConnectionInfo &info = event->info();
         _version = info._version;
+        _storageEngineType = info._storageEngineType;
         _isConnected = true;
-
-        // Do nothing if this is not "visible" connection
-        if (!_visible) {
-            return;
+        // Save Replica Set Status  
+        _repPrimary = event->getRepPrimary();                   // todo: what happens to this member if not replica set?
+        _repMembersHealths = event->getRepMembersHealths();
+        if (_settings->isReplicaSet()) {
+            _settings->setServerHost(_repPrimary.host());
+            _settings->setServerPort(_repPrimary.port());
         }
 
-        _bus->publish(new ConnectionEstablishedEvent(this));
+        _bus->publish(new ConnectionEstablishedEvent(this, _connectionType));
+
+        // Do nothing if this is not a "primary" connection
+        if (_connectionType != ConnectionPrimary)
+            return;
+
         clearDatabases();
-        for(std::vector<std::string>::const_iterator it = info._databases.begin(); it != info._databases.end(); ++it) {
+        for (std::vector<std::string>::const_iterator it = info._databases.begin(); it != info._databases.end(); ++it) {
             const std::string &name = *it;
             MongoDatabase *db  = new MongoDatabase(this, name);
             addDatabase(db);
@@ -155,7 +189,7 @@ namespace Robomongo {
         }
 
         clearDatabases();
-        for(std::vector<std::string>::iterator it = event->databaseNames.begin(); it != event->databaseNames.end(); ++it) {
+        for (std::vector<std::string>::iterator it = event->databaseNames.begin(); it != event->databaseNames.end(); ++it) {
             const std::string &name = *it;
             MongoDatabase *db  = new MongoDatabase(this, name);
             addDatabase(db);
@@ -175,6 +209,23 @@ namespace Robomongo {
     void MongoServer::runWorkerThread() {
         _client = new MongoWorker(_settings->clone(),
             AppRegistry::instance().settingsManager()->loadMongoRcJs(),
-            AppRegistry::instance().settingsManager()->batchSize());
+            AppRegistry::instance().settingsManager()->batchSize(),
+            AppRegistry::instance().settingsManager()->mongoTimeoutSec(),
+            AppRegistry::instance().settingsManager()->shellTimeoutSec());
+    }
+
+    void MongoServer::handle(CreateDatabaseResponse *event) {
+        genericResponseHandler(event, "Failed to create database.");
+    }
+
+    void MongoServer::handle(DropDatabaseResponse *event) {
+        genericResponseHandler(event, "Failed to drop database.");
+    }
+
+    void MongoServer::genericResponseHandler(Event *event, const std::string &userFriendlyMessage) {
+        if (!event->isError())
+            return;
+
+        _bus->publish(new OperationFailedEvent(this, event->error().errorMessage(), userFriendlyMessage));
     }
 }

src/robomongo/core/domain/MongoServer.h

@@ -8,10 +8,15 @@ namespace Robomongo
 {
     class MongoWorker;
     class MongoDatabase;
+    class EventBus;
+    class App;
+
+    // Messages
     class EstablishConnectionResponse;
     class LoadDatabaseNamesResponse;
     class InsertDocumentResponse;
-    class EventBus;
+    class CreateDatabaseResponse;
+    class DropDatabaseResponse;
 
     /**
      * @brief MongoServer represents active connection to MongoDB server.
@@ -29,7 +34,7 @@ namespace Robomongo
          * @param visible
          * @param defaultDatabase
          */
-        MongoServer(ConnectionSettings *connectionRecord, bool visible);
+        MongoServer(int handle, ConnectionSettings *connectionRecord, ConnectionType connectionType);
         ~MongoServer();
 
         void runWorkerThread();
@@ -52,7 +57,7 @@ namespace Robomongo
         void saveDocument(const mongo::BSONObj &obj, const MongoNamespace &ns);
         void removeDocuments(mongo::Query query, const MongoNamespace &ns, bool justOne = true);
         float version() const{ return _version; }
-
+        const std::string& getStorageEngineType() const { return _storageEngineType; }
 
         /**
          * @brief Returns associated connection record
@@ -63,28 +68,41 @@ namespace Robomongo
          * @brief Loads databases of this server asynchronously.
          */
         void loadDatabases();
-        bool visible() const { return _visible; }
         MongoWorker *const client() const { return _client; }
 
+        // --- Getters ---
+        const mongo::HostAndPort& getRepPrimary() const { return _repPrimary; }
+        const std::vector<bool>& getRepMembersHealths() const { return _repMembersHealths; }
+
     protected Q_SLOTS:
         void handle(EstablishConnectionResponse *event);
         void handle(LoadDatabaseNamesResponse *event);
         void handle(InsertDocumentResponse *event);
         void handle(RemoveDocumentResponse *event);
+        void handle(CreateDatabaseResponse *event);
+        void handle(DropDatabaseResponse *event);
 
     private:
         void clearDatabases();
         void addDatabase(MongoDatabase *database);
+        void genericResponseHandler(Event *event, const std::string &userFriendlyMessage);
 
-        MongoWorker* _client;
-        ConnectionSettings* _settings;
-        EventBus* _bus;
+        MongoWorker *_client;
+        ConnectionSettings *_settings;
+        EventBus *_bus;
+        App *_app;
 
         float _version;
-        bool _visible;
+        std::string _storageEngineType;
+        ConnectionType _connectionType;
         bool _isConnected;
+        int _handle;
 
         QList<MongoDatabase *> _databases;
+
+        // Replica Set Status
+        mongo::HostAndPort _repPrimary;
+        std::vector<bool> _repMembersHealths;   // todo: vector of pairs of host and health
     };
 
     class MongoServerLoadingDatabasesEvent : public Event

src/robomongo/core/domain/MongoShell.cpp

@@ -38,12 +38,12 @@ namespace Robomongo
         if (_scriptInfo.execute()) {
             AppRegistry::instance().bus()->publish(new ScriptExecutingEvent(this));
             AppRegistry::instance().bus()->send(_server->client(), new ExecuteScriptRequest(this, query(), dbName));
-            if(!_scriptInfo.script().isEmpty())
+            if (!_scriptInfo.script().isEmpty())
                 LOG_MSG(_scriptInfo.script(), mongo::logger::LogSeverity::Info());
         } else {
             AppRegistry::instance().bus()->publish(new ScriptExecutingEvent(this));
             _scriptInfo.setScript("");
-            AppRegistry::instance().bus()->send(_server->client(), new ExecuteScriptRequest(this,query() , dbName));
+            AppRegistry::instance().bus()->send(_server->client(), new ExecuteScriptRequest(this, query() , dbName));
         }
     }
 

src/robomongo/core/domain/MongoShell.h

@@ -10,7 +10,7 @@ namespace Robomongo
         Q_OBJECT
 
     public:
-        MongoShell(MongoServer *server,const ScriptInfo &scriptInfo);
+        MongoShell(MongoServer *server, const ScriptInfo &scriptInfo);
 
         void open(const std::string &script, const std::string &dbName = std::string());
         void query(int resultIndex, const MongoQueryInfo &info);
@@ -19,7 +19,7 @@ namespace Robomongo
         MongoServer *server() const { return _server; }
         std::string query() const;
         void execute(const std::string &dbName = std::string());
-        bool isExecutable() const {return _scriptInfo.execute(); }
+        bool isExecutable() const { return _scriptInfo.execute(); }
         const QString &title() const { return _scriptInfo.title(); }
         const CursorPosition &cursor() const { return _scriptInfo.cursor(); }
         void setScript(const QString &script) { return _scriptInfo.setScript(script); }

src/robomongo/core/domain/MongoUser.cpp

@@ -12,15 +12,15 @@ namespace Robomongo
         _version(version), _readOnly(false)
     {
         _id = obj.getField("_id").OID();
-        _name = BsonUtils::getField<mongo::String>(obj,"user");
-        _passwordHash = BsonUtils::getField<mongo::String>(obj,"pwd");
+        _name = BsonUtils::getField<mongo::String>(obj, "user");
+        _passwordHash = BsonUtils::getField<mongo::String>(obj, "pwd");
         if (_version<minimumSupportedVersion) {
-            _readOnly = BsonUtils::getField<mongo::Bool>(obj,"readOnly");
+            _readOnly = BsonUtils::getField<mongo::Bool>(obj, "readOnly");
         }     
         else {
-            _userSource = BsonUtils::getField<mongo::String>(obj,"userSource");
+            _userSource = BsonUtils::getField<mongo::String>(obj, "userSource");
             std::vector<mongo::BSONElement> roles = BsonUtils::getField<mongo::Array>(obj, "roles");
-            for (std::vector<mongo::BSONElement>::const_iterator it = roles.begin(); it!= roles.end(); ++it)
+            for (std::vector<mongo::BSONElement>::const_iterator it = roles.begin(); it != roles.end(); ++it)
             {
                 _role.push_back(BsonUtils::bsonelement_cast<std::string>(*it));
             }
@@ -28,7 +28,7 @@ namespace Robomongo
     }
 
     MongoUser::MongoUser(const float version) :
-        _version(version),_readOnly(false),_role() {}
+        _version(version), _readOnly(false), _role() {}
 
     mongo::BSONObj MongoUser::toBson() const
     {
@@ -50,7 +50,7 @@ namespace Robomongo
                 builder.append("userSource", _userSource);
 
             mongo::BSONArrayBuilder builderA;
-            for (RoleType::const_iterator it = _role.begin(); it!=_role.end(); ++it)
+            for (RoleType::const_iterator it = _role.begin(); it != _role.end(); ++it)
             {
                 builderA << *it;
             }

src/robomongo/core/domain/Notifier.cpp

@@ -25,10 +25,10 @@ namespace Robomongo
 {
     namespace detail
     {
-        bool isSimpleType(Robomongo::BsonTreeItem *item)
+        bool isSimpleType(Robomongo::BsonTreeItem const *item)
         {
-            return Robomongo::BsonUtils::isSimpleType(item->type())
-                || Robomongo::BsonUtils::isUuidType(item->type(), item->binType());
+            return BsonUtils::isSimpleType(item->type())
+                || BsonUtils::isUuidType(item->type(), item->binType());
         }
 
         bool isObjectIdType(Robomongo::BsonTreeItem *item)
@@ -38,12 +38,22 @@ namespace Robomongo
 
         bool isMultiSelection(const QModelIndexList &indexes)
         {
-            return indexes.count()>1;
+            return indexes.count() > 1;
         }
 
-        bool isDocumentType(BsonTreeItem *item)
+        bool isDocumentType(BsonTreeItem const *item)
         {
-            return Robomongo::BsonUtils::isDocument(item->type());
+            return BsonUtils::isDocument(item->type());
+        }
+
+        bool isArrayChild(BsonTreeItem const *item)
+        {
+            return BsonUtils::isArray(dynamic_cast<BsonTreeItem*>(item->parent())->type());
+        }
+
+        bool isDocumentRoot(BsonTreeItem const *item)
+        {
+            return ( item == item->superParent() );
         }
 
         /**
@@ -55,20 +65,20 @@ namespace Robomongo
         QModelIndexList uniqueRows(QModelIndexList indexes, bool returnSuperParents)
         {
             QModelIndexList result;
-            for (QModelIndexList::const_iterator it = indexes.begin(); it!=indexes.end(); ++it)
+            for (QModelIndexList::const_iterator it = indexes.begin(); it != indexes.end(); ++it)
             {
                 QModelIndex isUnique = *it;
                 Robomongo::BsonTreeItem *item = Robomongo::QtUtils::item<Robomongo::BsonTreeItem*>(isUnique);
-                if(item){                
-                    for (QModelIndexList::const_iterator jt = result.begin(); jt!=result.end(); ++jt)
+                if (item) {
+                    for (QModelIndexList::const_iterator jt = result.begin(); jt != result.end(); ++jt)
                     {
                         Robomongo::BsonTreeItem *jItem = Robomongo::QtUtils::item<Robomongo::BsonTreeItem*>(*jt);
-                        if (jItem && jItem->superParent() == item->superParent()){
+                        if (jItem && jItem->superParent() == item->superParent()) {
                             isUnique = QModelIndex();
                             break;
                         }
                     }
-                    if (isUnique.isValid()){
+                    if (isUnique.isValid()) {
                         if (returnSuperParents) {
                             // Move index onto "super parent" element before pushing it into result set
                             QModelIndex parent = isUnique.parent();
@@ -113,6 +123,12 @@ namespace Robomongo
         _copyValueAction = new QAction("Copy Value", wid);
         VERIFY(connect(_copyValueAction, SIGNAL(triggered()), SLOT(onCopyDocument())));
 
+        _copyValueNameAction = new QAction("Copy Name", wid);
+        VERIFY(connect(_copyValueNameAction, SIGNAL(triggered()), SLOT(onCopyNameDocument())));
+
+        _copyValuePathAction = new QAction("Copy Path", wid);
+        VERIFY(connect(_copyValuePathAction, SIGNAL(triggered()), SLOT(onCopyPathDocument())));
+
         _copyTimestampAction = new QAction("Copy Timestamp from ObjectId", wid);
         VERIFY(connect(_copyTimestampAction, SIGNAL(triggered()), SLOT(onCopyTimestamp())));
 
@@ -128,20 +144,29 @@ namespace Robomongo
         bool isSimple = false;
         bool isDocument = false;
         bool isObjectId = false;
+        bool isNotArrayChild = false;
+        bool isRoot = false;
 
         if (item) {
             isSimple = detail::isSimpleType(item);
             isDocument = detail::isDocumentType(item);
             isObjectId = detail::isObjectIdType(item);
+            isNotArrayChild = !detail::isArrayChild(item);
+            isRoot = detail::isDocumentRoot(item);
         }
 
         if (onItem && isEditable) menu->addAction(_editDocumentAction);
         if (onItem)               menu->addAction(_viewDocumentAction);
         if (isEditable)           menu->addAction(_insertDocumentAction);
-
         if (onItem && (isSimple || isDocument)) menu->addSeparator();
-
         if (onItem && isSimple)   menu->addAction(_copyValueAction);
+
+        if (onItem && (isSimple || isDocument) && isNotArrayChild && !isRoot)
+            menu->addAction(_copyValueNameAction);
+
+        if (onItem && (isSimple || isDocument) && !isRoot)
+            menu->addAction(_copyValuePathAction);
+
         if (onItem && isObjectId) menu->addAction(_copyTimestampAction);
         if (onItem && isDocument) menu->addAction(_copyJsonAction);
         if (onItem && isEditable) menu->addSeparator();
@@ -187,7 +212,7 @@ namespace Robomongo
                     break;
             }
 
-            isNeededRefresh=true;
+            isNeededRefresh = true;
             _shell->server()->removeDocuments(query, _queryInfo._info._ns);
         }
 
@@ -219,6 +244,53 @@ namespace Robomongo
         }
     }
 
+    void Notifier::onCopyNameDocument()
+    {
+        QModelIndex const& selectedInd = _observer->selectedIndex();
+        if (!selectedInd.isValid())
+            return;
+
+        BsonTreeItem const *documentItem = QtUtils::item<BsonTreeItem*>(selectedInd);
+        if (!documentItem)
+            return;
+
+        if (!(detail::isSimpleType(documentItem) || detail::isDocumentType(documentItem) ||
+            !detail::isArrayChild(documentItem) || !detail::isDocumentRoot(documentItem)))
+            return;
+
+        QClipboard *clipboard = QApplication::clipboard();
+        clipboard->setText(QString::fromStdString(documentItem->fieldName()));
+    }
+
+    void Notifier::onCopyPathDocument()
+    {
+        QModelIndex const& selectedInd = _observer->selectedIndex();
+        if (!selectedInd.isValid())
+            return;
+
+        BsonTreeItem const *documentItem = QtUtils::item<BsonTreeItem*>(selectedInd);
+        if (!documentItem)
+            return;
+
+        if (!(detail::isSimpleType(documentItem) || detail::isDocumentType(documentItem) ||
+            !detail::isDocumentRoot(documentItem)))
+            return;
+
+        QStringList namesList;
+        BsonTreeItem const *documentItemHelper = documentItem;
+
+        while (!detail::isDocumentRoot(documentItemHelper)) {
+            if (!detail::isArrayChild(documentItemHelper)) {
+                namesList.push_front(QString::fromStdString(documentItemHelper->fieldName()));
+            }
+
+            documentItemHelper = dynamic_cast<BsonTreeItem*>(documentItemHelper->parent());
+        }
+
+        QClipboard *clipboard = QApplication::clipboard();
+        clipboard->setText(namesList.join("."));
+    }
+
     void Notifier::handleDeleteCommand()
     {
         if (_observer->selectedIndexes().count() > 1) {
@@ -240,11 +312,11 @@ namespace Robomongo
         int answer = QMessageBox::question(dynamic_cast<QWidget*>(_observer), "Delete", QString("Do you want to delete %1 selected documents?").arg(selectedIndexes.count()));
         if (answer == QMessageBox::Yes) {
             std::vector<BsonTreeItem*> items;
-            for (QModelIndexList::const_iterator it = selectedIndexes.begin(); it!= selectedIndexes.end(); ++it) {
+            for (QModelIndexList::const_iterator it = selectedIndexes.begin(); it != selectedIndexes.end(); ++it) {
                 BsonTreeItem *item = QtUtils::item<BsonTreeItem*>(*it);
                 items.push_back(item);                
             }
-            deleteDocuments(items,true);
+            deleteDocuments(items, true);
         }
     }
 
@@ -260,7 +332,7 @@ namespace Robomongo
         BsonTreeItem *documentItem = QtUtils::item<BsonTreeItem*>(selectedIndex);
         std::vector<BsonTreeItem*> vec;
         vec.push_back(documentItem);
-        return deleteDocuments(vec,false);
+        return deleteDocuments(vec, false);
     }
 
     void Notifier::onEditDocument()
@@ -317,7 +389,7 @@ namespace Robomongo
             json, true, dynamic_cast<QWidget*>(_observer));
 
         editor->setWindowTitle("View Document");
-        editor->show();
+        editor->exec();
     }
 
     void Notifier::onInsertDocument()
@@ -376,19 +448,19 @@ namespace Robomongo
         QClipboard *clipboard = QApplication::clipboard();
 
         // new Date(parseInt(this.valueOf().slice(0,8), 16)*1000);
-        QString hexTimestamp = documentItem->value().mid(10,8);
+        QString hexTimestamp = documentItem->value().mid(10, 8);
         bool ok;
-        long long milliTimestamp = (long long)hexTimestamp.toLongLong(&ok,16)*1000;
+        long long milliTimestamp = (long long)hexTimestamp.toLongLong(&ok, 16)*1000;
 
         bool isSupportedDate = (miutil::minDate < milliTimestamp) && (milliTimestamp < miutil::maxDate);
 
-        boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
+        boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
         boost::posix_time::time_duration diff = boost::posix_time::millisec(milliTimestamp);
         boost::posix_time::ptime time = epoch + diff;
 
-        if(isSupportedDate)
+        if (isSupportedDate)
         {
-            std::string date = miutil::isotimeString(time,false,false);
+            std::string date = miutil::isotimeString(time, false, false);
             clipboard->setText("ISODate(\""+QString::fromStdString(date)+"\")");
         }
         else {
@@ -411,13 +483,13 @@ namespace Robomongo
 
          QClipboard *clipboard = QApplication::clipboard();
          mongo::BSONObj obj = documentItem->root();
-         if (documentItem != documentItem->superParent()){
-             obj = obj[QtUtils::toStdString(documentItem->key())].Obj();
+         if (documentItem != documentItem->superParent()) {
+             obj = obj[documentItem->fieldName()].Obj();
          }
          bool isArray = BsonUtils::isArray(documentItem->type());
          std::string str = BsonUtils::jsonString(obj, mongo::TenGen, 1,
                  AppRegistry::instance().settingsManager()->uuidEncoding(),
-                 AppRegistry::instance().settingsManager()->timeZone(),isArray);
+                 AppRegistry::instance().settingsManager()->timeZone(), isArray);
 
          const QString &json = QtUtils::toQString(str);
          clipboard->setText(json);

src/robomongo/core/domain/Notifier.h

@@ -18,10 +18,10 @@ namespace Robomongo
 
     namespace detail
     {
-        bool isSimpleType(BsonTreeItem *item);
+        bool isSimpleType(BsonTreeItem const *item);
         bool isObjectIdType(BsonTreeItem *item);
         bool isMultiSelection(const QModelIndexList &indexes);
-        bool isDocumentType(BsonTreeItem *item);
+        bool isDocumentType(BsonTreeItem const *item);
         QModelIndexList uniqueRows(QModelIndexList indexes, bool returnSuperParents = false);
     }
 
@@ -60,6 +60,10 @@ namespace Robomongo
         void handle(InsertDocumentResponse *event);
         void handle(RemoveDocumentResponse *event);
 
+    private Q_SLOTS:
+        void onCopyNameDocument();
+        void onCopyPathDocument();
+
     private:
         QAction *_deleteDocumentAction;
         QAction *_deleteDocumentsAction;
@@ -67,6 +71,8 @@ namespace Robomongo
         QAction *_viewDocumentAction;
         QAction *_insertDocumentAction;
         QAction *_copyValueAction;
+        QAction *_copyValueNameAction;
+        QAction *_copyValuePathAction;
         QAction *_copyTimestampAction;
         QAction *_copyJsonAction;
         const MongoQueryInfo _queryInfo;

src/robomongo/core/domain/ScriptInfo.cpp

@@ -62,7 +62,7 @@ namespace
 
 namespace Robomongo
 {
-    ScriptInfo::ScriptInfo(const QString &script, bool execute,const CursorPosition &position,
+    ScriptInfo::ScriptInfo(const QString &script, bool execute, const CursorPosition &position,
                            const QString &title, const QString &filePath) :
         _script(script),
         _execute(execute),
@@ -73,10 +73,10 @@ namespace Robomongo
     bool ScriptInfo::loadFromFile(const QString &filePath)
     {
         bool result = false;
-        QString filepath = QFileDialog::getOpenFileName(QApplication::activeWindow(), filePath,QString(), filterForScripts);
+        QString filepath = QFileDialog::getOpenFileName(QApplication::activeWindow(), filePath, QString(), filterForScripts);
         if (!filepath.isEmpty()) {
             QString out;
-            if (loadFromFileText(filepath,out)) {
+            if (loadFromFileText(filepath, out)) {
                 _script = out;
                 _filePath = filepath;
                 result = true;
@@ -95,7 +95,7 @@ namespace Robomongo
         QString filepath = QFileDialog::getSaveFileName(QApplication::activeWindow(),
             QObject::tr("Save As"), _filePath, filterForScripts);
 
-        if (saveToFileText(filepath,_script)) {
+        if (saveToFileText(filepath, _script)) {
             _filePath = filepath;
             return true;
         }

src/robomongo/core/engine/ScriptEngine.cpp

@@ -55,10 +55,12 @@ namespace mongo {
 
 namespace Robomongo
 {
-    ScriptEngine::ScriptEngine(ConnectionSettings *connection) :
+    ScriptEngine::ScriptEngine(ConnectionSettings *connection, int timeoutSec) :
         _connection(connection),
         _scope(NULL),
         _engine(NULL),
+        _timeoutSec(timeoutSec),
+        _initialized(false),
         _mutex(QMutex::Recursive) { }
 
     ScriptEngine::~ScriptEngine()
@@ -126,28 +128,40 @@ namespace Robomongo
         }
 
         // Esprima ECMAScript parser: http://esprima.org/
-        QFile file(":/robomongo/scripts/esprima.js");
-        if (!file.open(QIODevice::ReadOnly))
-            throw std::runtime_error("Unable to read esprima.js ");
+        std::string esprima = loadFile(":/robomongo/scripts/esprima.js", true);
+        _scope->exec(esprima, "(esprima)", false, true, true);
 
-        QTextStream in(&file);
-        QString esprima = in.readAll();
-
-        // Inject Esprima into Javascript scope
-        _scope->exec(QtUtils::toStdString(esprima), "(esprima)", true, true, true);
+        // UUID helpers
+        std::string uuidhelpers = loadFile(":/robomongo/scripts/uuidhelpers.js", true);
+        _scope->exec(uuidhelpers, "(uuidhelpers)", false, true, true);
 
         // Enable verbose shell reporting
         _scope->exec("_verboseShell = true;", "(verboseShell)", false, false, false);
 
         // Save original autocomplete function so it can be restored if overwritten by user preference
         _scope->exec("DB.autocompleteOriginal = DB.autocomplete;", "(saveOriginalAutocomplete)", false, false, false);
+
+        // Cache result of original "DB.autocomplete"
+        // Cache invalidated by the invalidateDbCollectionsCache() method.
+        std::string cacheAutocompletion =
+            "__robomongoAutocompletionCache = null;"
+            "DB.autocompleteCached = function(obj) { "
+            "   if (__robomongoAutocompletionCache == null) {"
+            "       __robomongoAutocompletionCache = DB.autocompleteOriginal(obj);"
+            "   }"
+            "   return __robomongoAutocompletionCache;"
+            "}";
+
+        _scope->exec(cacheAutocompletion, "", false, false, false);
+
+        _initialized = true;
     }
 
     MongoShellExecResult ScriptEngine::exec(const std::string &originalScript, const std::string &dbName)
     {
         QMutexLocker lock(&_mutex);
 
-        if(!_scope)
+        if (!_scope)
             return MongoShellExecResult();
 
         /*
@@ -177,7 +191,7 @@ namespace Robomongo
 
         use(dbName);
 
-        for(std::vector<std::string>::const_iterator it = statements.begin(); it != statements.end(); ++it)
+        for (std::vector<std::string>::const_iterator it = statements.begin(); it != statements.end(); ++it)
         {
             std::string statement = *it;
             // clear global objects
@@ -190,8 +204,8 @@ namespace Robomongo
                 try {
                     QElapsedTimer timer;
                     timer.start();
-                    if ( _scope->exec( statement , "(shell)" , false , true , false, 0 ) ) {
-                        _scope->exec( "__robomongoLastRes = __lastres__; shellPrintHelper( __lastres__ );" , "(shell2)" , true , true , false, 0);
+                    if ( _scope->exec( statement , "(shell)" , false , true , false, _timeoutSec * 1000) ) {
+                        _scope->exec( "__robomongoLastRes = __lastres__; shellPrintHelper( __lastres__ );" , "(shell2)" , true , true , false, _timeoutSec * 1000);
                     }
 
                     qint64 elapsed = timer.elapsed();
@@ -252,7 +266,7 @@ namespace Robomongo
     void ScriptEngine::ping()
     {
         QMutexLocker lock(&_mutex);
-        _scope->exec("if (db) { db.runCommand({ping:1}); }", "(ping)", false, false, false);
+        _scope->exec("if (db) { db.runCommand({ping:1}); }", "(ping)", false, false, false, 3000);
     }
 
     QStringList ScriptEngine::complete(const std::string &prefix, const AutocompletionMode mode)
@@ -262,7 +276,7 @@ namespace Robomongo
 
         try {
             if (mode == AutocompleteAll)
-                _scope->exec("DB.autocomplete = DB.autocompleteOriginal;", "", false, false, false);
+                _scope->exec("DB.autocomplete = DB.autocompleteCached;", "", false, false, false);
             else if (mode == AutocompleteNoCollectionNames)
                 _scope->exec("DB.autocomplete = function(obj){return [];}", "", false, false, false);
 
@@ -413,4 +427,25 @@ namespace Robomongo
 
         return true;
     }
+
+    void ScriptEngine::invalidateDbCollectionsCache() {
+        if (!_initialized)
+            return;
+
+        _scope->exec("__robomongoAutocompletionCache = null;", "", false, false, false);
+    }
+
+    std::string ScriptEngine::loadFile(const QString &path, bool throwOnError) {
+        QFile file(path);
+        if (!file.open(QIODevice::ReadOnly)) {
+            if (throwOnError)
+                throw std::runtime_error("Unable to load file");
+
+            return "";
+        }
+
+        QTextStream in(&file);
+        QString content = in.readAll();
+        return QtUtils::toStdString(content);
+    }
 }

src/robomongo/core/engine/ScriptEngine.h

@@ -15,7 +15,7 @@ namespace Robomongo
     {
 
     public:
-        ScriptEngine(ConnectionSettings *connection);
+        ScriptEngine(ConnectionSettings *connection, int timeoutSec);
         ~ScriptEngine();
 
         void init(bool isLoadMongoJs);
@@ -27,20 +27,23 @@ namespace Robomongo
         void ping();
         QStringList complete(const std::string &prefix, const AutocompletionMode mode);
 
+        void invalidateDbCollectionsCache();
+
     private:
         ConnectionSettings *_connection;
 
         MongoShellResult prepareResult(const std::string &type, const std::string &output, const std::vector<MongoDocumentPtr> &objects, qint64 elapsedms);
         MongoShellExecResult prepareExecResult(const std::vector<MongoShellResult> &results);
+        std::string loadFile(const QString &path, bool throwOnError);
 
         std::string getString(const char *fieldName);
 
         bool statementize(const std::string &script, std::vector<std::string> &outList, std::string &outError);
-        std::vector<std::string> statementize2(const std::string &script);
-//        void parseTree(JSParseNode * root, int indent, const std::string &script, std::vector<std::string> &list, bool topList);
 
+        int _timeoutSec;
         mongo::ScriptEngine *_engine;
         mongo::Scope *_scope;
         QMutex _mutex;
+        bool _initialized;
     };
 }

src/robomongo/core/events/MongoEvents.cpp

@@ -66,4 +66,5 @@ namespace Robomongo
     R_REGISTER_EVENT(ListenSshConnectionResponse)
     R_REGISTER_EVENT(LogEvent)
     R_REGISTER_EVENT(StopScriptRequest)
+    R_REGISTER_EVENT(OperationFailedEvent)
 }

src/robomongo/core/events/MongoEvents.h

@@ -30,25 +30,48 @@ namespace Robomongo
     {
         R_EVENT
 
-        EstablishConnectionRequest(QObject *sender) :
-            Event(sender) {}
+        EstablishConnectionRequest(QObject *sender, ConnectionType connectionType) :
+            Event(sender),
+            connectionType(connectionType) {}
+
+        ConnectionType connectionType;
     };
 
     class EstablishConnectionResponse : public Event
     {
         R_EVENT
 
-        EstablishConnectionResponse(QObject *sender, const ConnectionInfo &info) :
+        enum ErrorReason {
+            MongoConnection     = 0,
+            MongoAuth           = 1,
+            MongoSslConnection  = 2
+        };
+
+        EstablishConnectionResponse(QObject *sender, const ConnectionInfo &info, ConnectionType connectionType, 
+                                    const mongo::HostAndPort& repPrimary, const std::vector<bool>& repMembersHealths) :
             Event(sender),
-            _info(info) {}
+            _info(info),
+            connectionType(connectionType),
+            _repPrimary(repPrimary),
+            _repMembersHealths(repMembersHealths)
+            {}
 
-        EstablishConnectionResponse(QObject *sender, const EventError &error) :
-            Event(sender, error),_info() {}
+        EstablishConnectionResponse(QObject *sender, const EventError &error, ConnectionType connectionType, ErrorReason errorReason) :
+            Event(sender, error),
+            _info(),
+            connectionType(connectionType),
+            errorReason(errorReason) {}
+
+        // Getters
+        const ConnectionInfo &info() const { return _info; }
+        const mongo::HostAndPort& getRepPrimary() const { return _repPrimary; }
+        const std::vector<bool>& getRepMembersHealths() const { return _repMembersHealths; }
 
-        const ConnectionInfo &info() const{
-            return _info;
-        }
         const ConnectionInfo _info;
+        ConnectionType connectionType;
+        ErrorReason errorReason;
+        mongo::HostAndPort _repPrimary;
+        std::vector<bool> _repMembersHealths;    // todo: vector of host and health pair
     };
 
 
@@ -109,7 +132,7 @@ namespace Robomongo
             _databaseName(databaseName),
             _collectionInfos(collectionInfos) { }
 
-        LoadCollectionNamesResponse(QObject *sender,const EventError &error) :
+        LoadCollectionNamesResponse(QObject *sender, const EventError &error) :
             Event(sender, error) {}
 
         std::string databaseName() const { return _databaseName; }
@@ -125,7 +148,7 @@ namespace Robomongo
         R_EVENT
     public:
         LoadCollectionIndexesRequest(QObject *sender, const MongoCollectionInfo &collection) :
-        Event(sender),_collection(collection) {}
+        Event(sender), _collection(collection) {}
         MongoCollectionInfo collection() const { return _collection; }
     private:
         const MongoCollectionInfo _collection;
@@ -148,7 +171,7 @@ namespace Robomongo
     class EnsureIndexRequest : public Event
     {
         R_EVENT
-        EnsureIndexRequest(QObject *sender,const EnsureIndexInfo &oldInfo,const EnsureIndexInfo &newInfo) : Robomongo::Event(sender),oldInfo_(oldInfo),newInfo_(newInfo) {}
+        EnsureIndexRequest(QObject *sender, const EnsureIndexInfo &oldInfo, const EnsureIndexInfo &newInfo) : Robomongo::Event(sender), oldInfo_(oldInfo), newInfo_(newInfo) {}
         const EnsureIndexInfo &oldInfo() const
         {
             return oldInfo_;
@@ -172,7 +195,7 @@ namespace Robomongo
             _name(name) {}
 
         MongoCollectionInfo collection() const { return _collection; }
-        std::string name() const {return _name;}
+        std::string name() const { return _name; }
     private:
         const MongoCollectionInfo _collection;
         std::string _name;
@@ -182,14 +205,14 @@ namespace Robomongo
     {
         R_EVENT
     public:
-        DeleteCollectionIndexResponse(QObject *sender, const MongoCollectionInfo &collection,const std::string &index) :
-            Event(sender),_collection(collection),_index(index) {}
+        DeleteCollectionIndexResponse(QObject *sender, const MongoCollectionInfo &collection, const std::string &index) :
+            Event(sender), _collection(collection), _index(index) {}
 
         DeleteCollectionIndexResponse(QObject *sender, const EventError &error) :
             Event(sender, error) {}
 
         MongoCollectionInfo collection() const { return _collection; }
-        std::string index() const {return _index;}
+        std::string index() const { return _index; }
     private:
         MongoCollectionInfo _collection;
         std::string _index;
@@ -199,11 +222,11 @@ namespace Robomongo
     {
         R_EVENT
     public:
-        EditIndexRequest(QObject *sender, const MongoCollectionInfo &collection,const std::string &oldIndex,const std::string &newIndex) :
-            Event(sender),_collection(collection),_oldIndex(oldIndex),_newIndex(newIndex) {}
+        EditIndexRequest(QObject *sender, const MongoCollectionInfo &collection, const std::string &oldIndex, const std::string &newIndex) :
+            Event(sender), _collection(collection), _oldIndex(oldIndex), _newIndex(newIndex) {}
         MongoCollectionInfo collection() const { return _collection; }
-        std::string oldIndex() const {return _oldIndex;}
-        std::string newIndex() const {return _newIndex;}
+        std::string oldIndex() const { return _oldIndex; }
+        std::string newIndex() const { return _newIndex; }
     private:
         const MongoCollectionInfo _collection;
         std::string _oldIndex;
@@ -240,7 +263,7 @@ namespace Robomongo
             _databaseName(databaseName),
             _users(users) { }
 
-        LoadUsersResponse(QObject *sender,const EventError &error) :
+        LoadUsersResponse(QObject *sender, const EventError &error) :
             Event(sender, error) {}
 
         std::string databaseName() const { return _databaseName; }
@@ -282,7 +305,7 @@ namespace Robomongo
             _databaseName(databaseName),
             _functions(functions) { }
 
-        LoadFunctionsResponse(QObject *sender,const EventError &error) :
+        LoadFunctionsResponse(QObject *sender, const EventError &error) :
             Event(sender, error) {}
 
         std::string databaseName() const { return _databaseName; }
@@ -440,14 +463,27 @@ namespace Robomongo
         R_EVENT
 
     public:
-        CreateCollectionRequest(QObject *sender, const MongoNamespace &ns) :
-            Event(sender),
-            _ns(ns) {}
+        CreateCollectionRequest(QObject *sender, const MongoNamespace &ns, 
+                                                 const mongo::BSONObj& extraOptions,
+                                                 long long size = 0,
+                                                 bool capped = false,
+                                                 int maxDocNum = 0
+                                                 ) :
+            Event(sender), _ns(ns), _extraOptions(extraOptions),
+            _size(size), _capped(capped), _maxDocNum(maxDocNum) {}
 
-        MongoNamespace ns() const { return _ns; }
+        MongoNamespace getNs() const { return _ns; }
+        long long getSize() const { return _size; }
+        bool getCapped() const { return _capped; }
+        int getMaxDocNum() const { return _maxDocNum; }
+        const mongo::BSONObj getExtraOptions() const { return _extraOptions; }
 
     private:
         const MongoNamespace _ns;
+        const long long _size;
+        const bool _capped;
+        const int _maxDocNum;
+        const mongo::BSONObj _extraOptions;
     };
 
     class CreateCollectionResponse : public Event
@@ -580,7 +616,7 @@ namespace Robomongo
             _to(databaseTo, collection) {}
 
         MongoWorker *worker() const { return _worker; }
-        MongoNamespace from() const { return _from;}
+        MongoNamespace from() const { return _from; }
         MongoNamespace to() const { return _to; }
     private:
         MongoWorker *_worker;
@@ -806,7 +842,7 @@ namespace Robomongo
     {
         R_EVENT
 
-        AutocompleteResponse(QObject *sender,const QStringList &list, const std::string &prefix) :
+        AutocompleteResponse(QObject *sender, const QStringList &list, const std::string &prefix) :
             Event(sender),
             list(list),
             prefix(prefix) {}
@@ -879,14 +915,26 @@ namespace Robomongo
     {
         R_EVENT
 
-        ConnectionFailedEvent(QObject *sender, const std::string& message) :
-            Event(sender),
-            message(message) {}
+        enum Reason {
+            MongoConnection    = 1,
+            MongoAuth          = 2,
+            SshConnection      = 3,
+            SshChannel         = 4,
+            SslConnection      = 5
+        };
 
-        ConnectionFailedEvent(QObject *sender, const EventError &error) :
-            Event(sender, error) {}
+        ConnectionFailedEvent(QObject *sender, int serverHandle, ConnectionType connectionType,
+                              const std::string& message, Reason reason) :
+            Event(sender),
+            message(message),
+            reason(reason),
+            serverHandle(serverHandle),
+            connectionType(connectionType) {}
 
         std::string message;
+        Reason reason;
+        ConnectionType connectionType;
+        int serverHandle;
     };
 
 //    class ScriptExecute
@@ -895,11 +943,13 @@ namespace Robomongo
     {
         R_EVENT
 
-        ConnectionEstablishedEvent(MongoServer *server) :
+        ConnectionEstablishedEvent(MongoServer *server, ConnectionType type) :
             Event((QObject *)server),
-            server(server) { }
+            server(server),
+            connectionType(type) { }
 
         MongoServer *server;
+        ConnectionType connectionType;
     };
 
     class DatabaseListLoadedEvent : public Event
@@ -973,6 +1023,20 @@ namespace Robomongo
             Event(sender) { }
     };
 
+    class OperationFailedEvent : public Event
+    {
+        R_EVENT
+
+    public:
+        OperationFailedEvent(QObject *sender, const std::string &technicalErrorMessage, const std::string &userFriendlyErrorMessage) :
+            technicalErrorMessage(technicalErrorMessage),
+            userFriendlyErrorMessage(userFriendlyErrorMessage),
+            Event(sender) { }
+
+        std::string technicalErrorMessage;
+        std::string userFriendlyErrorMessage;
+    };
+
     class QueryWidgetUpdatedEvent : public Event
     {
         R_EVENT
@@ -996,38 +1060,43 @@ namespace Robomongo
     {
     R_EVENT
 
-        EstablishSshConnectionRequest(QObject *sender, SshTunnelWorker* worker, ConnectionSettings* settings, bool visible) :
+        EstablishSshConnectionRequest(QObject *sender, int serverHandle, SshTunnelWorker* worker, ConnectionSettings* settings, ConnectionType connectionType) :
             Event(sender),
             worker(worker),
             settings(settings),
-            visible(visible) {}
+            serverHandle(serverHandle),
+            connectionType(connectionType) {}
 
         ConnectionSettings* settings;
-        bool visible;
+        ConnectionType connectionType;
         SshTunnelWorker* worker;
+        int serverHandle;
     };
 
     class EstablishSshConnectionResponse : public Event
     {
     R_EVENT
 
-        EstablishSshConnectionResponse(QObject *sender, SshTunnelWorker* worker, ConnectionSettings* settings, bool visible, int localport) :
+        EstablishSshConnectionResponse(QObject *sender, int serverHandle, SshTunnelWorker* worker, ConnectionSettings* settings, ConnectionType connectionType, int localport) :
             Event(sender),
             worker(worker),
             settings(settings),
-            visible(visible),
+            connectionType(connectionType),
+            serverHandle(serverHandle),
             localport(localport) {}
 
-        EstablishSshConnectionResponse(QObject *sender, const EventError &error, SshTunnelWorker* worker, ConnectionSettings* settings, bool visible) :
+        EstablishSshConnectionResponse(QObject *sender, int serverHandle, const EventError &error, SshTunnelWorker* worker, ConnectionSettings* settings, ConnectionType connectionType) :
             Event(sender, error),
             worker(worker),
             settings(settings),
-            visible(visible) {}
+            serverHandle(serverHandle),
+            connectionType(connectionType) {}
 
         ConnectionSettings* settings;
-        bool visible;
+        ConnectionType connectionType;
         SshTunnelWorker* worker;
         int localport;
+        int serverHandle;
     };
 
     /**
@@ -1038,23 +1107,34 @@ namespace Robomongo
     {
     R_EVENT
 
-        ListenSshConnectionRequest(QObject *sender) :
-                Event(sender) {}
+        ListenSshConnectionRequest(QObject *sender, int serverHandle, ConnectionType connectionType) :
+            Event(sender),
+            serverHandle(serverHandle),
+            connectionType(connectionType) {}
+
+        ConnectionType connectionType;
+        int serverHandle;
     };
 
     class ListenSshConnectionResponse : public Event
     {
     R_EVENT
 
-        ListenSshConnectionResponse(QObject *sender, ConnectionSettings* settings) :
+        ListenSshConnectionResponse(QObject *sender, int serverHandle, ConnectionSettings* settings, ConnectionType connectionType) :
             Event(sender),
-            settings(settings) {}
+            settings(settings),
+            serverHandle(serverHandle),
+            connectionType(connectionType) {}
 
-        ListenSshConnectionResponse(QObject *sender, const EventError &error, ConnectionSettings* settings) :
+        ListenSshConnectionResponse(QObject *sender, const EventError &error, int serverHandle, ConnectionSettings* settings, ConnectionType connectionType) :
             Event(sender, error),
-            settings(settings) {}
+            settings(settings),
+            serverHandle(serverHandle),
+            connectionType(connectionType) {}
 
         ConnectionSettings* settings;
+        ConnectionType connectionType;
+        int serverHandle;
     };
 
     class LogEvent : public Event
@@ -1062,10 +1142,10 @@ namespace Robomongo
     R_EVENT
 
         enum LogLevel {
-            ERROR  = 1,
-            WARN   = 2,
-            INFO   = 3,
-            DEBUG  = 100 // log as much as possible
+            RBM_ERROR  = 1,
+            RBM_WARN   = 2,
+            RBM_INFO   = 3,
+            RBM_DEBUG  = 100 // log as much as possible
         };
 
         LogEvent(QObject *sender, const std::string& message, LogLevel level) :

src/robomongo/core/events/MongoEventsInfo.cpp

@@ -22,8 +22,10 @@ namespace Robomongo
             _databases(),
             _version(0.0f) {}
 
-        ConnectionInfo::ConnectionInfo(const std::string &address, const std::vector<std::string> &databases, float version) :
+        ConnectionInfo::ConnectionInfo(const std::string &address, const std::vector<std::string> &databases, 
+            float version, const std::string& storageEngine) :
            _address(address),
            _databases(databases),
-           _version(version) {}
+           _version(version),
+           _storageEngineType(storageEngine) {}
 }

src/robomongo/core/events/MongoEventsInfo.h

@@ -35,9 +35,10 @@ namespace Robomongo
     struct ConnectionInfo
     {
         ConnectionInfo();
-        ConnectionInfo(const std::string &address, const std::vector<std::string> &databases, float version);
+        ConnectionInfo(const std::string &address, const std::vector<std::string> &databases, float version, const std::string& storageEngine);
         const std::string _address;
         const std::vector<std::string> _databases;
         const float _version;
+        const std::string _storageEngineType;
     };
 }

src/robomongo/core/mongodb/MongoClient.cpp

@@ -1,5 +1,7 @@
 #include "robomongo/core/mongodb/MongoClient.h"
 
+#include "mongo/db/namespace_string.h"
+
 #include "robomongo/core/domain/MongoDocument.h"
 #include "robomongo/core/utils/BsonUtils.h"
 #include "robomongo/shell/bson/json.h"
@@ -13,7 +15,7 @@ namespace
         using namespace Robomongo::BsonUtils;
         Robomongo::EnsureIndexInfo info(collection);
         info._name = getField<mongo::String>(obj, "name");
-        mongo::BSONObj keyObj = getField<mongo::Object>(obj,"key");
+        mongo::BSONObj keyObj = getField<mongo::Object>(obj, "key");
         if (keyObj.isValid()) {
             info._request = jsonString(keyObj, mongo::TenGen, 1, Robomongo::DefaultEncoding, Robomongo::Utc);
         }
@@ -56,11 +58,18 @@ namespace Robomongo
         float result = 0.0f;
         mongo::BSONObj resultObj;
         _dbclient->runCommand("db", BSON("buildInfo" << "1"), resultObj);
-        std::string resultStr = BsonUtils::getField<mongo::String>(resultObj,"version");
+        std::string resultStr = BsonUtils::getField<mongo::String>(resultObj, "version");
         result = atof(resultStr.c_str());
         return result;
     }
 
+    std::string MongoClient::getStorageEngineType() const
+    {
+        mongo::BSONObj resultObj;
+        _dbclient->runCommand("db", BSON("serverStatus" << "1"), resultObj);
+        return resultObj.getObjectField("storageEngine").getStringField("name");
+    }
+
     std::vector<std::string> MongoClient::getDatabaseNames() const
     {
         typedef std::list<std::string> cont_string_t;
@@ -87,7 +96,7 @@ namespace Robomongo
         float ver = getVersion();
         while (cursor->more()) {
             mongo::BSONObj bsonObj = cursor->next();
-            MongoUser user(ver,bsonObj);
+            MongoUser user(ver, bsonObj);
             users.push_back(user);
         }
 
@@ -157,13 +166,13 @@ namespace Robomongo
 
         for (std::list<mongo::BSONObj>::iterator it = indexes.begin(); it != indexes.end(); ++it) {
             mongo::BSONObj bsonObj = *it;
-            result.push_back(makeEnsureIndexInfoFromBsonObj(collection,bsonObj));
+            result.push_back(makeEnsureIndexInfoFromBsonObj(collection, bsonObj));
         }
 
         return result;
     }
 
-    void MongoClient::ensureIndex(const EnsureIndexInfo &oldInfo,const EnsureIndexInfo &newInfo) const
+    void MongoClient::ensureIndex(const EnsureIndexInfo &oldInfo, const EnsureIndexInfo &newInfo) const
     {   
         std::string ns = newInfo._collection.ns().toString();
 
@@ -172,8 +181,8 @@ namespace Robomongo
 
         mongo::BSONObj keys = mongo::Robomongo::fromjson(newInfo._request);
         mongo::BSONObjBuilder toSave;
-        bool cache=true;
-        int version =-1;
+        bool cache = true;
+        int version = -1;
 
         toSave.append( "ns" , ns );
         toSave.append( "key" , keys );
@@ -361,9 +370,27 @@ namespace Robomongo
         _dbclient->dropDatabase(dbName);
     }
 
-    void MongoClient::createCollection(const MongoNamespace &ns)
+    void MongoClient::createCollection(const std::string& ns, long long size, bool capped, int max, const mongo::BSONObj& extraOptions, mongo::BSONObj* info)
     {
-        _dbclient->createCollection(ns.toString());
+        verify(!capped || size);
+        mongo::BSONObj o;
+        if (info == 0)
+            info = &o;
+        mongo::BSONObjBuilder b;
+        std::string db = mongo::nsToDatabase(ns);
+        b.append("create", ns.c_str() + db.length() + 1);
+        if (size) {
+            b.append("size", size);
+        }
+        if (capped) {
+            b.append("capped", true);
+        }
+        if (max) {
+            b.append("max", max);
+        }
+        b.appendElements(extraOptions);
+
+        _dbclient->runCommand(db.c_str(), b.done(), *info);
     }
 
     void MongoClient::renameCollection(const MongoNamespace &ns, const std::string &newCollectionName)
@@ -400,7 +427,7 @@ namespace Robomongo
         }
     }
 
-    void MongoClient::copyCollectionToDiffServer(mongo::DBClientBase *const fromServ,const MongoNamespace &from, const MongoNamespace &to)
+    void MongoClient::copyCollectionToDiffServer(mongo::DBClientBase *const fromServ, const MongoNamespace &from, const MongoNamespace &to)
     {
         if (!_dbclient->exists(to.toString()))
             _dbclient->createCollection(to.toString());
@@ -497,9 +524,9 @@ namespace Robomongo
     std::vector<MongoCollectionInfo> MongoClient::runCollStatsCommand(const std::vector<std::string> &namespaces)
     {
         std::vector<MongoCollectionInfo> infos;
-        for (std::vector<std::string>::const_iterator it = namespaces.begin(); it!=namespaces.end(); ++it) {
+        for (std::vector<std::string>::const_iterator it = namespaces.begin(); it != namespaces.end(); ++it) {
             MongoCollectionInfo info = runCollStatsCommand(*it);
-            if (info.ns().isValid()){
+            if (info.ns().isValid()) {
                 infos.push_back(info);
             }            
         }

src/robomongo/core/mongodb/MongoClient.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <mongo/client/dbclientinterface.h>
+#include <mongo/bson/bsonobj.h>
+
 #include "robomongo/core/Core.h"
 #include "robomongo/core/domain/MongoQueryInfo.h"
 #include "robomongo/core/domain/MongoUser.h"
@@ -17,6 +19,7 @@ namespace Robomongo
         std::vector<std::string> getCollectionNames(const std::string &dbname) const;
         std::vector<std::string> getDatabaseNames() const;
         float getVersion() const;
+        std::string getStorageEngineType() const;
 
         std::vector<MongoUser> getUsers(const std::string &dbName);
         void createUser(const std::string &dbName, const MongoUser &user, bool overwrite);
@@ -37,11 +40,11 @@ namespace Robomongo
         void createDatabase(const std::string &dbName);
         void dropDatabase(const std::string &dbName);
 
-        void createCollection(const MongoNamespace &ns);
+        void createCollection(const std::string &ns, long long size, bool capped, int max, const mongo::BSONObj& extraOptions, mongo::BSONObj* info = nullptr);
         void renameCollection(const MongoNamespace &ns, const std::string &newCollectionName);
         void duplicateCollection(const MongoNamespace &ns, const std::string &newCollectionName);
         void dropCollection(const MongoNamespace &ns);
-        void copyCollectionToDiffServer(mongo::DBClientBase *const,const MongoNamespace &from, const MongoNamespace &to);
+        void copyCollectionToDiffServer(mongo::DBClientBase *const, const MongoNamespace &from, const MongoNamespace &to);
 
         void insertDocument(const mongo::BSONObj &obj, const MongoNamespace &ns);
         void saveDocument(const mongo::BSONObj &obj, const MongoNamespace &ns);

src/robomongo/core/mongodb/MongoWorker.cpp

@@ -2,34 +2,45 @@
 
 #include <QThread>
 
+#include "mongo/client/global_conn_pool.h"
+#include "mongo/client/replica_set_monitor.h"
+#include <mongo/util/net/ssl_manager.h>
+#include <mongo/util/net/ssl_options.h>
+
 #include "robomongo/core/events/MongoEvents.h"
 #include "robomongo/core/engine/ScriptEngine.h"
 #include "robomongo/core/EventBus.h"
 #include "robomongo/core/AppRegistry.h"
 #include "robomongo/core/mongodb/MongoClient.h"
 #include "robomongo/core/settings/ConnectionSettings.h"
+#include "robomongo/core/settings/ReplicaSetSettings.h"
 #include "robomongo/core/domain/MongoShellResult.h"
 #include "robomongo/core/domain/MongoCollectionInfo.h"
 #include "robomongo/core/settings/CredentialSettings.h"
 #include "robomongo/core/settings/SettingsManager.h"
+#include "robomongo/core/settings/SslSettings.h"
 #include "robomongo/core/utils/Logger.h"
 #include "robomongo/core/utils/QtUtils.h"
 
 namespace Robomongo
 {
-    MongoWorker::MongoWorker(ConnectionSettings *connection, bool isLoadMongoRcJs, int batchSize, QObject *parent) : QObject(parent),
-        _connection(connection),
+    MongoWorker::MongoWorker(ConnectionSettings *connection, bool isLoadMongoRcJs, int batchSize,
+                             int mongoTimeoutSec, int shellTimeoutSec, QObject *parent) : QObject(parent),
         _scriptEngine(NULL),
-        _dbclient(NULL),
         _isAdmin(true),
         _isLoadMongoRcJs(isLoadMongoRcJs),
         _batchSize(batchSize),
         _timerId(-1),
-        _isQuiting(0)
-    {         
+        _dbAutocompleteCacheTimerId(-1),
+        _mongoTimeoutSec(mongoTimeoutSec),
+        _shellTimeoutSec(shellTimeoutSec),
+        _isQuiting(0),
+        _dbclient(nullptr),
+        _dbclientRepSet(nullptr),
+        _connSettings(connection)
+    {
         _thread = new QThread();
         moveToThread(_thread);
-        VERIFY(connect( _thread, SIGNAL(started()), this, SLOT(init()) ));
         VERIFY(connect( _thread, SIGNAL(finished()), _thread, SLOT(deleteLater()) ));
         VERIFY(connect( _thread, SIGNAL(finished()), this, SLOT(deleteLater()) ));
         _thread->start();
@@ -39,6 +50,13 @@ namespace Robomongo
     {
         if (_timerId == event->timerId()) {
             keepAlive();
+            return;
+        }
+
+        if (_dbAutocompleteCacheTimerId == event->timerId() &&
+            _scriptEngine != NULL) {
+            _scriptEngine->invalidateDbCollectionsCache();
+            return;
         }
     }
 
@@ -70,11 +88,12 @@ namespace Robomongo
     void MongoWorker::init()
     {        
         try {
-            _scriptEngine = new ScriptEngine(_connection);
+            _scriptEngine = new ScriptEngine(_connSettings, _shellTimeoutSec);
             _scriptEngine->init(_isLoadMongoRcJs);
-            _scriptEngine->use(_connection->defaultDatabase());
+            _scriptEngine->use(_connSettings->defaultDatabase());
             _scriptEngine->setBatchSize(_batchSize);
             _timerId = startTimer(pingTimeMs);
+            _dbAutocompleteCacheTimerId = startTimer(30000);
         } catch (const std::exception &ex) {
             LOG_MSG(ex.what(), mongo::logger::LogSeverity::Error());
         }
@@ -93,9 +112,13 @@ namespace Robomongo
 
     MongoWorker::~MongoWorker()
     {
-        killTimer(_timerId);
-        delete _dbclient;
-        delete _connection;
+        if (_timerId != -1)
+            killTimer(_timerId);
+
+        if (_dbAutocompleteCacheTimerId != -1)
+            killTimer(_dbAutocompleteCacheTimerId);
+
+        delete _connSettings;
         delete _scriptEngine;
 
         // QThread "_thread" and MongoWorker itself will be deleted later
@@ -116,10 +139,31 @@ namespace Robomongo
         QMutexLocker lock(&_firstConnectionMutex);
 
         try {
-            mongo::DBClientBase *conn = getConnection();
-            bool hasPrimary = _connection->hasEnabledPrimaryCredential();
-            if (hasPrimary) {
-                CredentialSettings *credentials = _connection->primaryCredential();
+            mongo::DBClientBase *conn = getConnection(true);
+            if (conn == NULL) {
+                // Protection by default value: Logically/ideally, this error should never be seen.
+                auto errorReason = std::string("Connection failure: Unknown error.");
+                if (_connSettings->sslSettings()->sslEnabled())
+                {
+                    // Note: Currently mongo-shell does not provide any interface to fetch actual error details
+                    // for some SSL connection failures that's why we are unable to show exact error here. 
+                    errorReason = "SSL tunnel failure: Network is unreachable or SSL connection rejected by server.";
+                }
+                else
+                {
+                    errorReason = "Network is unreachable.";
+                }
+
+                resetGlobalSSLparams();
+
+                reply(event->sender(), new EstablishConnectionResponse(this,
+                    EventError(errorReason), event->connectionType,
+                    EstablishConnectionResponse::MongoConnection));
+                return;
+            }
+
+            if (_connSettings->hasEnabledPrimaryCredential()) {
+                CredentialSettings *credentials = _connSettings->primaryCredential();
 
                 // Building BSON object:
                 mongo::BSONObj authParams(mongo::BSONObjBuilder()
@@ -138,21 +182,60 @@ namespace Robomongo
                 if (dbName.compare("admin") != 0) // dbName is NOT "admin"
                     _isAdmin = false;
             }
+
             boost::scoped_ptr<MongoClient> client(getClient());
             std::vector<std::string> dbNames = getDatabaseNamesSafe();
-            reply(event->sender(), new EstablishConnectionResponse(this, ConnectionInfo(_connection->getFullAddress(), dbNames, client->getVersion()) ));
+
+            // If we do not have databases, it means that we are unable to
+            // execute "listdatabases" command and we have nothing to show.
+            if (dbNames.size() == 0)
+                throw mongo::DBException("Failed to execute \"listdatabases\" command.", 0);
+
+            // todo: move to func. getRepSetStatus();
+            mongo::HostAndPort repPrimary;
+            std::vector<bool> repMembersHealths;
+            if (_connSettings->isReplicaSet()) 
+            {
+                // Refresh view of Replica Set Monitor to get live data
+                auto repSetMonitor = mongo::globalRSMonitorManager.getMonitor(_dbclientRepSet->getSetName());
+                repSetMonitor->startOrContinueRefresh().refreshAll();
+
+                // Update connection settings with primary(master) address and port
+                repPrimary = repSetMonitor->getMasterOrUassert();
+                _connSettings->setServerHost(repPrimary.host());
+                _connSettings->setServerPort(repPrimary.port());
+
+                // Save health of members
+                for (auto const& member : _connSettings->replicaSetSettings()->membersToHostAndPort()) 
+                {
+                    repMembersHealths.push_back(repSetMonitor->isHostUp(member));
+                }
+            }
+
+            // Init MongoWorker
+            init();
+
+            resetGlobalSSLparams();
+
+            reply(event->sender(), new EstablishConnectionResponse(this, ConnectionInfo(_connSettings->getFullAddress(), 
+                dbNames, client->getVersion(), client->getStorageEngineType()), event->connectionType, repPrimary, repMembersHealths));
         } catch(const std::exception &ex) {
-            reply(event->sender(), new EstablishConnectionResponse(this, EventError(ex.what())));
-            LOG_MSG(ex.what(), mongo::logger::LogSeverity::Error());
+            resetGlobalSSLparams();
+
+            auto errorReason = _connSettings->sslSettings()->sslEnabled() ?
+                EstablishConnectionResponse::ErrorReason::MongoSslConnection : 
+                EstablishConnectionResponse::ErrorReason::MongoAuth;
+
+            reply(event->sender(), 
+                new EstablishConnectionResponse(this, EventError(ex.what()), event->connectionType, errorReason));
         }
     }
 
     std::string MongoWorker::getAuthBase() const
     {
-        bool hasPrimary = _connection->hasEnabledPrimaryCredential();
-        if(hasPrimary){
-            return _connection->primaryCredential()->databaseName();
-        }
+        if (_connSettings->hasEnabledPrimaryCredential())
+            return _connSettings->primaryCredential()->databaseName();
+
         return std::string();
     }
 
@@ -161,17 +244,16 @@ namespace Robomongo
         DatabasesContainerType result;
         std::string authBase = getAuthBase();
         if (!_isAdmin && !authBase.empty()) {
-            result.push_back(_connection->primaryCredential()->databaseName());
+            result.push_back(_connSettings->primaryCredential()->databaseName());
             return result;
         }
 
         try {
             boost::scoped_ptr<MongoClient> client(getClient());
             result = client->getDatabaseNames();
-        } catch(const std::exception &ex) {
+        } catch(const std::exception &) {
             if (!authBase.empty())
                 result.push_back(authBase);
-            LOG_MSG(ex.what(), mongo::logger::LogSeverity::Error());
         }
         return result;
     }
@@ -202,7 +284,7 @@ namespace Robomongo
             if (dbNames.size()) {
                 reply(event->sender(), new LoadDatabaseNamesResponse(this, dbNames));
             } else {
-                reply(event->sender(), new LoadDatabaseNamesResponse(this, EventError("Unable to load database names.")));
+                reply(event->sender(), new LoadDatabaseNamesResponse(this, EventError("Failed to execute \"listdatabases\" command.")));
             }
         } catch(const mongo::DBException &ex) {
             reply(event->sender(), new LoadDatabaseNamesResponse(this, EventError(ex.what())));
@@ -263,7 +345,7 @@ namespace Robomongo
         const EnsureIndexInfo &oldInfo = event->oldInfo();
         try {
             boost::scoped_ptr<MongoClient> client(getClient());
-            client->ensureIndex(oldInfo,newInfo);
+            client->ensureIndex(oldInfo, newInfo);
             const std::vector<EnsureIndexInfo> &ind = client->getIndexes(newInfo._collection);
             client->done();
 
@@ -278,7 +360,7 @@ namespace Robomongo
     {
         try {
             boost::scoped_ptr<MongoClient> client(getClient());
-            client->dropIndexFromCollection(event->collection(),event->name());
+            client->dropIndexFromCollection(event->collection(), event->name());
             client->done();
             reply(event->sender(), new DeleteCollectionIndexResponse(this, event->collection(), event->name()));
         } catch(const mongo::DBException &ex) {
@@ -291,7 +373,7 @@ namespace Robomongo
     {
         try {
             boost::scoped_ptr<MongoClient> client(getClient());
-            client->renameIndexFromCollection(event->collection(),event->oldIndex(),event->newIndex());
+            client->renameIndexFromCollection(event->collection(), event->oldIndex(), event->newIndex());
             const std::vector<EnsureIndexInfo> &ind = client->getIndexes(event->collection());
             client->done();
 
@@ -372,6 +454,11 @@ namespace Robomongo
     void MongoWorker::handle(ExecuteScriptRequest *event)
     {
         try {
+            if (!_scriptEngine) {
+                reply(event->sender(), new ExecuteScriptResponse(this, EventError("MongoDB Shell was not initialized")));
+                return;
+            }
+
             MongoShellExecResult result = _scriptEngine->exec(event->script, event->databaseName);
             reply(event->sender(), new ExecuteScriptResponse(this, result, event->script.empty()));
         } catch(const mongo::DBException &ex) {
@@ -386,6 +473,10 @@ namespace Robomongo
     void MongoWorker::handle(StopScriptRequest *)
     {
         try {
+            if (!_scriptEngine) {
+                return;
+            }
+
             _scriptEngine->interrupt();
         } catch(const mongo::DBException &ex) {
             LOG_MSG(ex.what(), mongo::logger::LogSeverity::Error());
@@ -395,6 +486,11 @@ namespace Robomongo
     void MongoWorker::handle(AutocompleteRequest *event)
     {
         try {
+            if (!_scriptEngine) {
+                reply(event->sender(), new AutocompleteResponse(this, EventError("MongoDB Shell was not initialized")));
+                return;
+            }
+
             QStringList list = _scriptEngine->complete(event->prefix, event->mode);
             reply(event->sender(), new AutocompleteResponse(this, list, event->prefix));
         } catch(const mongo::DBException &ex) {
@@ -441,7 +537,8 @@ namespace Robomongo
     {
         try {
             boost::scoped_ptr<MongoClient> client(getClient());
-            client->createCollection(event->ns());
+            client->createCollection(event->getNs().toString(), event->getSize(), event->getCapped(),
+                event->getMaxDocNum(), event->getExtraOptions());
             client->done();
 
             reply(event->sender(), new CreateCollectionResponse(this));
@@ -498,7 +595,7 @@ namespace Robomongo
         try {
             boost::scoped_ptr<MongoClient> client(getClient());
             MongoWorker *cl = event->worker();
-            client->copyCollectionToDiffServer(cl->_dbclient,event->from(),event->to());
+            client->copyCollectionToDiffServer(cl->_dbclient.get(), event->from(), event->to());
             client->done();
 
             reply(event->sender(), new CopyCollectionToDiffServerResponse(this));
@@ -564,16 +661,53 @@ namespace Robomongo
         }
     }
 
-    mongo::DBClientBase *MongoWorker::getConnection()
+    mongo::DBClientBase *MongoWorker::getConnection(bool mayReturnNull /* = false */)
     {
-        if (!_dbclient) {
-            // Timeout for operations is 10 seconds.
-            // Connect timeout is fixed, but short, at 5 seconds (see headers for DBClientConnection)
-            mongo::DBClientConnection *conn = new mongo::DBClientConnection(true, 10);
-            conn->connect(_connection->info());
-            _dbclient = conn;
+        // --- Configure SSL first --- // todo: move to function?
+        // As a precaution reset SSL global params for any kind of connection request (SSL or non-SSL)
+        resetGlobalSSLparams();
+        // Update global SSL mode and global mongo SSL settings
+        if (_connSettings->sslSettings()->sslEnabled())
+        {
+            // Force SSL mode for outgoing connections
+            mongo::sslGlobalParams.sslMode.store(mongo::SSLParams::SSLMode_requireSSL);
+            updateGlobalSSLparams();
+        }
+        else
+        {
+            // Disable forced SSL mode for outgoing connections
+            mongo::sslGlobalParams.sslMode.store(mongo::SSLParams::SSLMode_allowSSL);
+        }
+
+        // --- Perform connection ---
+        if (_connSettings->isReplicaSet()) {  // connection to replica set 
+            if (!_dbclientRepSet) {
+                _dbclientRepSet = std::unique_ptr<mongo::DBClientReplicaSet>(
+                    // todo: where to get name of replica? (i.e. repset) - todo: this if causes crash after app close
+                    new mongo::DBClientReplicaSet("repset",_connSettings->replicaSetSettings()->membersToHostAndPort(), _mongoTimeoutSec));
+
+                bool const connStatus = _dbclientRepSet->connect();
+                
+                if (!connStatus) {
+                    return nullptr;
+                }
+            }
+            return _dbclientRepSet.get();
+        }
+        else {                              // connection to single server
+            if (!_dbclient) {
+                // Timeout for operations
+                // Connect timeout is fixed, but short, at 5 seconds (see headers for DBClientConnection)
+                _dbclient = std::unique_ptr<mongo::DBClientConnection>(new mongo::DBClientConnection(true, _mongoTimeoutSec));
+
+                mongo::Status status = _dbclient->connect(_connSettings->info());
+
+                if (!status.isOK() && mayReturnNull) {
+                    return nullptr;
+                }
+            }
+            return _dbclient.get();
         }
-        return _dbclient;
     }
 
     MongoClient *MongoWorker::getClient()
@@ -581,6 +715,37 @@ namespace Robomongo
         return new MongoClient(getConnection());
     }
 
+    void MongoWorker::updateGlobalSSLparams() const
+    {
+        resetGlobalSSLparams();
+        const SslSettings * const sslSettings = _connSettings->sslSettings();
+        mongo::sslGlobalParams.sslAllowInvalidCertificates = sslSettings->allowInvalidCertificates();
+        if (!mongo::sslGlobalParams.sslAllowInvalidCertificates)
+        {
+            mongo::sslGlobalParams.sslCAFile = sslSettings->caFile();
+        }
+        if (sslSettings->usePemFile())
+        {
+            mongo::sslGlobalParams.sslPEMKeyFile = sslSettings->pemKeyFile();
+            mongo::sslGlobalParams.sslPEMKeyPassword = sslSettings->pemPassPhrase();
+        }
+        if (sslSettings->useAdvancedOptions())
+        {
+            mongo::sslGlobalParams.sslCRLFile = sslSettings->crlFile();
+            mongo::sslGlobalParams.sslAllowInvalidHostnames = sslSettings->allowInvalidHostnames();
+        }
+    }
+
+    void MongoWorker::resetGlobalSSLparams() const
+    {
+        mongo::sslGlobalParams.sslAllowInvalidCertificates = false;
+        mongo::sslGlobalParams.sslCAFile = "";
+        mongo::sslGlobalParams.sslPEMKeyFile = "";
+        mongo::sslGlobalParams.sslPEMKeyPassword = "";
+        mongo::sslGlobalParams.sslCRLFile = "";
+        mongo::sslGlobalParams.sslAllowInvalidHostnames = false;
+    }
+
     /**
      * @brief Send event to this MongoWorker
      */

src/robomongo/core/mongodb/MongoWorker.h

@@ -4,6 +4,8 @@
 #include <QMutex>
 #include <unordered_set>
 
+#include <mongo/client/dbclient_rs.h> // todo: move
+
 #include "robomongo/core/events/MongoEvents.h"
 
 QT_BEGIN_NAMESPACE
@@ -23,7 +25,8 @@ namespace Robomongo
 
     public:
         typedef std::vector<std::string> DatabasesContainerType;
-        explicit MongoWorker(ConnectionSettings *connection, bool isLoadMongoRcJs, int batchSize, QObject *parent = NULL);
+        explicit MongoWorker(ConnectionSettings *connection, bool isLoadMongoRcJs, int batchSize,
+                             int mongoTimeoutSec, int shellTimeoutSec, QObject *parent = NULL);
         ~MongoWorker();
         enum { pingTimeMs = 60 * 1000 };
         void interrupt();
@@ -127,17 +130,29 @@ namespace Robomongo
          * @brief Send event to this MongoWorker
          */
         void send(Event *event);
+
         DatabasesContainerType getDatabaseNamesSafe();
         std::string getAuthBase() const;
 
-        mongo::DBClientBase *_dbclient;
-        mongo::DBClientBase *getConnection();
+        mongo::DBClientBase *getConnection(bool mayReturnNull = false);
         MongoClient *getClient();
 
+        /**
+        *@brief Update global mongo SSL settings (mongo::sslGlobalParams) according to active connection 
+        *       request's SSL settings.
+        */
+        void updateGlobalSSLparams() const;
+
+        /**
+        *@brief Reset global mongo SSL settings (mongo::sslGlobalParams) into default zero state
+        */
+        void resetGlobalSSLparams() const;
+
         /**
          * @brief Send reply event to object 'obj'
          */
         void reply(QObject *receiver, Event *event);
+
         QThread *_thread;
         QMutex _firstConnectionMutex;
 
@@ -147,13 +162,19 @@ namespace Robomongo
         const bool _isLoadMongoRcJs;
         const int _batchSize;
         int _timerId;
+        int _dbAutocompleteCacheTimerId;
+        int _mongoTimeoutSec;
+        int _shellTimeoutSec;
         QAtomicInteger<int> _isQuiting;
 
-        ConnectionSettings *_connection;
+        std::unique_ptr<mongo::DBClientConnection> _dbclient;
+        std::unique_ptr<mongo::DBClientReplicaSet> _dbclientRepSet;
+
+        ConnectionSettings *_connSettings;
 
         // Collection of created databases.
         // Starting from 3.0, MongoDB drops empty databases.
-        // It means, we do not find a way to create "empty" database.
+        // It means, we did not find a way to create "empty" database.
         // We save all created databases in this collection and merge with
         // list of real databases returned from MongoDB server.
         std::unordered_set<std::string> _createdDbs;

src/robomongo/core/mongodb/SshTunnelWorker.cpp

@@ -1,6 +1,8 @@
 #include "robomongo/core/mongodb/SshTunnelWorker.h"
 
 #include <QThread>
+#include <QElapsedTimer>
+
 #include "robomongo/core/utils/QtUtils.h"
 #include "robomongo/core/utils/Logger.h"
 #include "robomongo/core/settings/ConnectionSettings.h"
@@ -15,50 +17,23 @@ namespace Robomongo
 {
     SshTunnelWorker::SshTunnelWorker(ConnectionSettings *settings) : QObject(),
         _settings(settings),
-        _sshConfig(NULL),
-        _sshSession(NULL)
+        _sshSession(NULL),
+        _configCreator(settings)
     {
         _thread = new QThread();
         moveToThread(_thread);
-        VERIFY(connect(_thread, SIGNAL(started()), this, SLOT(init())));
         VERIFY(connect(_thread, SIGNAL(finished()), _thread, SLOT(deleteLater())));
         VERIFY(connect(_thread, SIGNAL(finished()), this, SLOT(deleteLater())));
         _thread->start();
     }
 
-    void SshTunnelWorker::init()
-    {
-        try {
-            SshSettings *ssh = _settings->sshSettings();
-
-            // We are going to access raw char* buffers, so prepare copies
-            // of strings (and rest of the things for symmetry)
-            _sshhost = ssh->host();
-            _sshport = ssh->port();
-            _remotehost = _settings->serverHost();
-            _remoteport = _settings->serverPort();
-            _localip = "127.0.0.1";
-            _localport = 27040;
-
-            _userName = ssh->userName();
-            _userPassword = ssh->userPassword();
-            _privateKeyFile = ssh->privateKeyFile();
-            _publicKeyFile = ssh->publicKeyFile();
-            _passphrase = ssh->passphrase();
-            _authMethod = ssh->authMethod(); // "password" or "publickey"
-        }
-        catch (const std::exception &ex) {
-            LOG_MSG(ex.what(), mongo::logger::LogSeverity::Error());
-        }
-    }
-
     SshTunnelWorker::~SshTunnelWorker()
     {
         // QThread "_thread" and MongoWorker itself will be deleted later
         // (see MongoWorker() constructor)
 
         delete _settings;
-        delete _sshConfig;
+        printf("SSH tunnel closed.\n");
     }
 
     void SshTunnelWorker::stopAndDelete() {
@@ -71,30 +46,12 @@ namespace Robomongo
             if (_isQuiting)
                 return;
 
-            _sshConfig = new rbm_ssh_tunnel_config;
-            _sshConfig->sshserverip = const_cast<char*>(_sshhost.c_str());
-            _sshConfig->sshserverport = static_cast<unsigned int>(_sshport);
-            _sshConfig->remotehost = const_cast<char*>(_remotehost.c_str());
-            _sshConfig->remoteport = static_cast<unsigned int>(_remoteport);
-            _sshConfig->localip = const_cast<char*>(_localip.c_str());
-            _sshConfig->localport = static_cast<unsigned int>(_localport);
-
-            _sshConfig->username = const_cast<char*>(_userName.c_str());
-            _sshConfig->password = const_cast<char*>(_userPassword.c_str());
-            _sshConfig->privatekeyfile = const_cast<char*>(_privateKeyFile.c_str());
-            _sshConfig->publickeyfile = _publicKeyFile.empty() ? NULL : const_cast<char*>(_publicKeyFile.c_str());
-            _sshConfig->passphrase = const_cast<char*>(_passphrase.c_str());
-            _sshConfig->authtype = (_authMethod == "publickey") ? RBM_SSH_AUTH_TYPE_PUBLICKEY : RBM_SSH_AUTH_TYPE_PASSWORD;
-
-            _sshConfig->logcontext = this;
-            _sshConfig->logcallback = &SshTunnelWorker::logCallbackHandler;
-            _sshConfig->loglevel = (rbm_ssh_log_type) _settings->sshSettings()->logLevel(); // RBM_SSH_LOG_TYPE_DEBUG;
-
-            if ((_sshSession = rbm_ssh_session_create(_sshConfig)) == 0) {
-                // Cleanup config structure
-                delete _sshConfig;
-                _sshConfig = NULL;
+            // Additionally configure "rbm_ssh_tunnel_config"
+            _configCreator.config()->logcontext = this;
+            _configCreator.config()->logcallback = &SshTunnelWorker::logCallbackHandler;
+            _configCreator.config()->loglevel = (rbm_ssh_log_type) _settings->sshSettings()->logLevel(); // RBM_SSH_LOG_TYPE_DEBUG;
 
+            if ((_sshSession = rbm_ssh_session_create(_configCreator.config())) == 0) {
                 // Not much we can say about this error
                 throw std::runtime_error("Failed to create SSH session");
             }
@@ -113,20 +70,16 @@ namespace Robomongo
                 rbm_ssh_session_close(_sshSession);
                 _sshSession = NULL;
 
-                // Cleanup config
-                delete _sshConfig;
-                _sshConfig = NULL;
-
                 throw std::runtime_error(ss.str());
             }
 
             reply(event->sender(), new EstablishSshConnectionResponse(
-                    this, event->worker, event->settings, event->visible, _sshConfig->localport));
+                    this, event->serverHandle, event->worker, event->settings, event->connectionType, _configCreator.config()->localport));
 
         } catch (const std::exception& ex) {
             reply(event->sender(),
-                new EstablishSshConnectionResponse(this, EventError(ex.what()),
-                event->worker, event->settings, event->visible));
+                new EstablishSshConnectionResponse(this, event->serverHandle, EventError(ex.what()),
+                event->worker, event->settings, event->connectionType));
 
             // In case of error in connection, we should cleanup SshTunnelWorker
             stopAndDelete();
@@ -134,28 +87,50 @@ namespace Robomongo
     }
 
     void SshTunnelWorker::handle(ListenSshConnectionRequest *event) {
-
-        // do it here, i.e. cycle
-
         try {
             if (_isQuiting)
                 return;
 
-            if (_sshSession == NULL || _sshConfig == NULL)
+            if (_sshSession == NULL)
                 return;
 
+            // We are running this timer in order to distinguish between two
+            // types of errors:
+            // 1) SSH tunnel wasn't successfully created
+            // 2) SSH tunnel was disconnected
+            // This is used now only for UI error message, that we show to user.
+            QElapsedTimer timer;
+            timer.start();
+
             // This function will block until all TCP connections disconnects.
             // Initially, it will wait for at least one such connection.
             if (rbm_ssh_open_tunnel(_sshSession) != 0) {
+
+                qint64 elapsed = timer.elapsed();
+                bool wasDisconnected = elapsed > 20000; // More than 20 seconds passed
+
                 // Prepare copy of error message (if any)
                 std::string error(_sshSession->lasterror);
 
                 std::stringstream ss;
-                ss << "You are disconnected from SSH tunnel ("
-                    << _settings->sshSettings()->host() << ":"
-                    << _settings->sshSettings()->port() << "). "
-                    << "Please initiate a new connection and reopen all tabs.\n\nError:\n"
-                    << error;
+
+                if (wasDisconnected) {
+                    ss << "You are disconnected from SSH tunnel ("
+                        << _settings->sshSettings()->host() << ":"
+                        << _settings->sshSettings()->port() << "). "
+                        << "Please initiate a new connection and reopen all tabs.\n\nError:\n"
+                        << error;
+                } else {
+                    ss << "Cannot establish SSH tunnel ("
+                        << _settings->sshSettings()->host() << ":"
+                        << _settings->sshSettings()->port() << "). "
+                        << "\n\nError:\n"
+                        << error;
+                }
+
+                // Cleanup session
+                rbm_ssh_session_close(_sshSession);
+                _sshSession = NULL;
 
                 throw std::runtime_error(ss.str());
             }
@@ -164,7 +139,7 @@ namespace Robomongo
 
         } catch (const std::exception& ex) {
             reply(event->sender(),
-                  new ListenSshConnectionResponse(this, EventError(ex.what()), _settings));
+                  new ListenSshConnectionResponse(this, EventError(ex.what()), event->serverHandle, _settings, event->connectionType));
         }
 
         // When we done with SSH (i.e. rbm_ssh_open_tunnel exits) regardless
@@ -195,4 +170,60 @@ namespace Robomongo
     void SshTunnelWorker::logCallbackHandler(void *context, char *message, int level) {
         static_cast<SshTunnelWorker*>(context)->log(message, level);
     }
+
+    /*
+     * SshTunnelConfigCreator
+     */
+    SshTunnelConfigCreator::SshTunnelConfigCreator(ConnectionSettings *settings) {
+        SshSettings *ssh = settings->sshSettings();
+
+        // We are going to access raw char* buffers, so prepare copies
+        // of strings (and rest of the things for symmetry)
+        _sshhost = ssh->host();
+        _sshport = ssh->port();
+        _remotehost = settings->serverHost();
+        _remoteport = settings->serverPort();
+        _localip = "127.0.0.1";
+        _localport = 27040;
+
+        _userName = ssh->userName();
+        _userPassword = ssh->userPassword();
+        _privateKeyFile = ssh->privateKeyFile();
+        _publicKeyFile = ssh->publicKeyFile();
+        _passphrase = ssh->passphrase();
+        _authMethod = ssh->authMethod(); // "password" or "publickey"
+
+        // Use "askedPassword" for both passphrase and password if required
+        if (ssh->askPassword()) {
+            _passphrase = ssh->askedPassword();
+            _userPassword = ssh->askedPassword();
+        }
+
+        _sshConfig = new rbm_ssh_tunnel_config;
+        _sshConfig->sshserverhost = const_cast<char*>(_sshhost.c_str());
+        _sshConfig->sshserverport = static_cast<unsigned int>(_sshport);
+        _sshConfig->remotehost = const_cast<char*>(_remotehost.c_str());
+        _sshConfig->remoteport = static_cast<unsigned int>(_remoteport);
+        _sshConfig->localip = const_cast<char*>(_localip.c_str());
+        _sshConfig->localport = static_cast<unsigned int>(_localport);
+
+        _sshConfig->username = const_cast<char*>(_userName.c_str());
+        _sshConfig->password = const_cast<char*>(_userPassword.c_str());
+        _sshConfig->privatekeyfile = const_cast<char*>(_privateKeyFile.c_str());
+        _sshConfig->publickeyfile = _publicKeyFile.empty() ? NULL : const_cast<char*>(_publicKeyFile.c_str());
+        _sshConfig->passphrase = const_cast<char*>(_passphrase.c_str());
+        _sshConfig->authtype = (_authMethod == "publickey") ? RBM_SSH_AUTH_TYPE_PUBLICKEY : RBM_SSH_AUTH_TYPE_PASSWORD;
+
+        // Default settings
+        _sshConfig->logcontext = NULL;
+        _sshConfig->logcallback = NULL;
+        _sshConfig->loglevel = RBM_SSH_LOG_TYPE_ERROR;
+
+    }
+
+    SshTunnelConfigCreator::~SshTunnelConfigCreator() {
+        delete _sshConfig;
+    }
 }
+
+

src/robomongo/core/mongodb/SshTunnelWorker.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <QObject>
+
 #include <robomongo/ssh/ssh.h>
 #include "robomongo/core/events/MongoEvents.h"
 
@@ -17,6 +18,34 @@ namespace Robomongo
     class EstablishSshConnectionRequest;
     class ListenSshConnectionRequest;
 
+    /*
+     * Helper class for creating rbm_ssh_tunnel_config from ConnectionSettings
+     * Automatically deletes allocated structure
+     */
+    class SshTunnelConfigCreator {
+    public:
+        explicit SshTunnelConfigCreator(ConnectionSettings *settings);
+        ~SshTunnelConfigCreator();
+        rbm_ssh_tunnel_config *config() { return _sshConfig; }
+
+    private:
+        std::string _sshhost;
+        int _sshport;
+        std::string _remotehost;
+        int _remoteport;
+        std::string _localip;
+        int _localport;
+
+        std::string _userName;
+        std::string _userPassword;
+        std::string _privateKeyFile;
+        std::string _publicKeyFile;
+        std::string _passphrase;
+        std::string _authMethod; // "password" or "publickey"
+
+        rbm_ssh_tunnel_config* _sshConfig;
+    };
+
     class SshTunnelWorker : public QObject
     {
     Q_OBJECT
@@ -31,7 +60,6 @@ namespace Robomongo
         void stopAndDelete();
 
     protected Q_SLOTS: // handlers:
-        void init();
         void handle(EstablishSshConnectionRequest *event);
         void handle(ListenSshConnectionRequest *event);
 
@@ -42,21 +70,9 @@ namespace Robomongo
         QThread *_thread;
         QAtomicInteger<int> _isQuiting;
         ConnectionSettings* _settings;
-        rbm_ssh_tunnel_config* _sshConfig;
         rbm_ssh_session* _sshSession;
 
-        std::string _sshhost;
-        int _sshport;
-        std::string _remotehost;
-        int _remoteport;
-        std::string _localip;
-        int _localport;
-
-        std::string _userName;
-        std::string _userPassword;
-        std::string _privateKeyFile;
-        std::string _publicKeyFile;
-        std::string _passphrase;
-        std::string _authMethod; // "password" or "publickey"
+        SshTunnelConfigCreator _configCreator;
     };
+
 }

src/robomongo/core/settings/ConnectionSettings.cpp

@@ -3,7 +3,9 @@
 #include <stdio.h>
 
 #include "robomongo/core/settings/CredentialSettings.h"
+#include "robomongo/core/settings/ReplicaSetSettings.h"
 #include "robomongo/core/settings/SshSettings.h"
+#include "robomongo/core/settings/SslSettings.h"
 #include "robomongo/core/utils/QtUtils.h"
 
 namespace
@@ -11,6 +13,8 @@ namespace
     const unsigned port = 27017;
     const char *defaultServerHost = "localhost";
     const char *defaultNameConnection = "New Connection";
+
+    const int maxLength = 300;
 }
 
 namespace Robomongo
@@ -23,16 +27,23 @@ namespace Robomongo
         _connectionName(defaultNameConnection),
         _host(defaultServerHost),
         _port(port),
-        _sshSettings(new SshSettings()) { }
+        _imported(false),
+        _sshSettings(new SshSettings()),
+        _sslSettings(new SslSettings()),
+        _isReplicaSet(false),
+        _replicaSetSettings(new ReplicaSetSettings())
+    { }
 
     void ConnectionSettings::fromVariant(const QVariantMap &map) {
         setConnectionName(QtUtils::toStdString(map.value("connectionName").toString()));
-        setServerHost(QtUtils::toStdString(map.value("serverHost").toString()));
+        setServerHost(QtUtils::toStdString(map.value("serverHost").toString().left(maxLength)));
         setServerPort(map.value("serverPort").toInt());
         setDefaultDatabase(QtUtils::toStdString(map.value("defaultDatabase").toString()));
-
+        //// Temporarily disable Replica Setet - feature is under development
+        //setReplicaSet(map.value("isReplicaSet").toBool());       
+        
         QVariantList list = map.value("credentials").toList();
-        for(QVariantList::const_iterator it = list.begin(); it != list.end(); ++it) {
+        for (QVariantList::const_iterator it = list.begin(); it != list.end(); ++it) {
             QVariant var = *it;
             CredentialSettings *credential = new CredentialSettings(var.toMap());
             addCredential(credential);
@@ -42,6 +53,15 @@ namespace Robomongo
             _sshSettings->fromVariant(map.value("ssh").toMap());
         }
 
+        if (map.contains("ssl")) {
+            _sslSettings->fromVariant(map.value("ssl").toMap());
+        }
+
+        //// Temporarily disable Replica Setet - feature is under development
+        //if (isReplicaSet()) {
+        //    _replicaSetSettings->fromVariant(map.value("replicaSet").toMap());
+        //}
+
 //#ifdef MONGO_SSL
 //      ,SSLInfo(map.value("sslEnabled").toBool(),QtUtils::toStdString(map.value("sslPemKeyFile").toString()))
 //#endif
@@ -54,6 +74,8 @@ namespace Robomongo
     {
         clearCredentials();
         delete _sshSettings;
+        delete _sslSettings;
+        delete _replicaSetSettings; // todo: unique_ptr
     }
 
     /**
@@ -75,6 +97,9 @@ namespace Robomongo
         setServerHost(source->serverHost());
         setServerPort(source->serverPort());
         setDefaultDatabase(source->defaultDatabase());
+        setImported(source->imported());
+        //// Temporarily disable Replica Setet - feature is under development
+        //setReplicaSet(source->isReplicaSet());
 
         clearCredentials();
         QList<CredentialSettings *> cred = source->credentials();
@@ -82,8 +107,9 @@ namespace Robomongo
             addCredential((*it)->clone());
         }
 
-        // Clone SSH settings
         _sshSettings = source->sshSettings()->clone();
+        _sslSettings = source->sslSettings()->clone();
+        _replicaSetSettings = source->_replicaSetSettings->clone(); // todo: leak candidate
 
 //#ifdef MONGO_SSL
 //        setSslInfo(source->sslInfo());
@@ -100,19 +126,26 @@ namespace Robomongo
         map.insert("serverHost", QtUtils::toQString(serverHost()));
         map.insert("serverPort", serverPort());
         map.insert("defaultDatabase", QtUtils::toQString(defaultDatabase()));
+        //// Temporarily disable Replica Setet - feature is under development
+        //map.insert("isReplicaSet", isReplicaSet());
+        //if (isReplicaSet()) {
+        //    map.insert("replicaSet", _replicaSetSettings->toVariant());
+        //}
+
 #ifdef MONGO_SSL
         SSLInfo infl = _info.sslInfo();
         map.insert("sslEnabled", infl._sslSupport);
         map.insert("sslPemKeyFile", QtUtils::toQString(infl._sslPEMKeyFile));
 #endif
         QVariantList list;
-        for(QList<CredentialSettings *>::const_iterator it = _credentials.begin(); it != _credentials.end(); ++it) {
+        for (QList<CredentialSettings *>::const_iterator it = _credentials.begin(); it != _credentials.end(); ++it) {
             CredentialSettings *credential = *it;
             list.append(credential->toVariant());
         }
         map.insert("credentials", list);
 
         map.insert("ssh", _sshSettings->toVariant());
+        map.insert("ssl", _sslSettings->toVariant());
 
         return map;
     }
@@ -120,7 +153,7 @@ namespace Robomongo
      CredentialSettings *ConnectionSettings::findCredential(const std::string &databaseName) const
      {
          CredentialSettings *result = NULL;
-         for(QList<CredentialSettings *>::const_iterator it = _credentials.begin(); it != _credentials.end(); ++it) {
+         for (QList<CredentialSettings *>::const_iterator it = _credentials.begin(); it != _credentials.end(); ++it) {
              CredentialSettings *cred = *it;
              if (cred->databaseName() == databaseName) {
                  result = cred;
@@ -152,12 +185,13 @@ namespace Robomongo
     }
 
     /**
-     * @brief Returns primary credential, or NULL if no credentials exists.
+     * @brief Returns primary credential
      */
     CredentialSettings *ConnectionSettings::primaryCredential()
     {
-        if (_credentials.count() == 0)
-            return NULL;
+        if (_credentials.count() == 0) {
+            _credentials.append(new CredentialSettings());
+        }
 
         return _credentials.at(0);
     }

src/robomongo/core/settings/ConnectionSettings.h

@@ -10,6 +10,9 @@ namespace Robomongo
 {
     class CredentialSettings;
     class SshSettings;
+    class SslSettings;
+    class ReplicaSetSettings;
+
     /**
      * @brief Represents connection record
      */
@@ -70,6 +73,12 @@ namespace Robomongo
         std::string defaultDatabase() const { return _defaultDatabase; }
         void setDefaultDatabase(const std::string &defaultDatabase) { _defaultDatabase = defaultDatabase; }
 
+        /**
+         * Was this connection imported from somewhere?
+         */
+        bool imported() const { return _imported; }
+        void setImported(bool imported) { _imported = imported; }
+
         /**
          * @brief Adds credential to this connection
          */
@@ -87,7 +96,7 @@ namespace Robomongo
         bool hasEnabledPrimaryCredential();
 
         /**
-         * @brief Returns primary credential, or NULL if no credentials exists.
+         * @brief Returns primary credential
          */
         CredentialSettings *primaryCredential();
 
@@ -143,15 +152,27 @@ namespace Robomongo
         }
 
         SshSettings *sshSettings() const { return _sshSettings; }
+        SslSettings *sslSettings() const { return _sslSettings; }
+        ReplicaSetSettings *replicaSetSettings() const { return _replicaSetSettings; }
+
+        bool isReplicaSet() const { return _isReplicaSet; }
+        void setReplicaSet(bool flag) { _isReplicaSet = flag; }
 
     private:
         CredentialSettings *findCredential(const std::string &databaseName) const;
+
         std::string _connectionName;
         std::string _host;
         int _port;
         std::string _defaultDatabase;
         QList<CredentialSettings *> _credentials;
         SshSettings *_sshSettings;
+        SslSettings *_sslSettings;
+        bool _isReplicaSet;
+        ReplicaSetSettings *_replicaSetSettings;
+
+        // Was this connection imported from somewhere?
+        bool _imported;
     };
 }
 

src/robomongo/core/settings/CredentialSettings.h

@@ -57,7 +57,7 @@ namespace Robomongo
         std::string _userName;
         std::string _userPassword;
         std::string _databaseName;
-        std::string _mechanism; // authentication mechanism
+        std::string _mechanism; // authentication mechanism (MONGODB-CR or SCRAM-SHA-1)
 
         /**
          * @brief Flag, indecating whether we should use this

src/robomongo/core/settings/ReplicaSetSettings.cpp

@@ -0,0 +1,58 @@
+#include "robomongo/core/settings/ReplicaSetSettings.h"
+
+#include "robomongo/core/utils/QtUtils.h"
+
+namespace Robomongo
+{
+
+    ReplicaSetSettings::ReplicaSetSettings() 
+        : _members(), _readPreference(ReadPreference::PRIMARY) 
+    {}
+
+    ReplicaSetSettings *ReplicaSetSettings::clone() const 
+    {
+        ReplicaSetSettings *cloned = new ReplicaSetSettings(*this);
+        return cloned;
+    }
+
+    QVariant ReplicaSetSettings::toVariant() const 
+    {
+        QVariantMap map;
+        int idx = 0;
+        for (std::string const& str : _members) {
+            map.insert(QString::number(idx), QtUtils::toQString(str));
+            ++idx;
+        }
+        map.insert("readPreference", static_cast<int>(readPreference()));
+        return map;
+    }
+
+    void ReplicaSetSettings::fromVariant(const QVariantMap &map) 
+    {
+        // Extract and set replica members
+        std::vector<std::string> vec;
+        auto itr = map.begin();
+        int idx = 0;
+        do
+        {
+            itr = map.find(QString::number(idx));
+            if (map.end() == itr) break;
+            vec.push_back(itr->toString().toStdString());
+            ++idx;
+        } while (map.end() != itr);
+        setMembers(vec);
+        // Extract and set read reference
+        setReadPreference(static_cast<ReadPreference>(map.value("readPreference").toInt()));
+    }
+
+    const std::vector<mongo::HostAndPort> ReplicaSetSettings::membersToHostAndPort() const 
+    {
+        std::vector<mongo::HostAndPort> membersHostAndPort;
+        for (auto const& member : _members)
+        {
+            membersHostAndPort.push_back(mongo::HostAndPort(member));
+        }
+        return membersHostAndPort;
+    }
+
+}

src/robomongo/core/settings/ReplicaSetSettings.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <QString>
+#include <QVariant>
+#include <QVariantMap>
+
+#include <mongo/util/net/hostandport.h>
+
+namespace Robomongo
+{
+    class ReplicaSetSettings
+    {
+    public:
+        enum class ReadPreference
+        {
+            PRIMARY             = 0,
+            PRIMARY_PREFERRED   = 1
+        };
+
+        ReplicaSetSettings();
+
+        /**
+         * Clones Replica Set settings.
+         */
+        ReplicaSetSettings* clone() const;
+
+        /**
+         * Converts to QVariantMap
+         */
+        QVariant toVariant() const;
+        void fromVariant(const QVariantMap &map);
+
+        // Getters
+        const std::vector<std::string>& members() const { return _members; }
+        const std::vector<mongo::HostAndPort> membersToHostAndPort() const;
+        ReadPreference readPreference() const { return _readPreference; }
+
+        // Setters
+        void setMembers(const std::vector<std::string>& members) { _members = members; }
+        void setReadPreference(ReadPreference readPreference) { _readPreference = readPreference; }
+
+    private:
+        std::vector<std::string> _members;
+        ReadPreference _readPreference;
+    };
+}

src/robomongo/core/settings/SettingsManager.cpp

@@ -7,7 +7,11 @@
 #include <serializer.h>
 
 #include "robomongo/core/settings/ConnectionSettings.h"
+#include "robomongo/core/settings/CredentialSettings.h"
+#include "robomongo/core/settings/SshSettings.h"
+#include "robomongo/core/settings/SslSettings.h"
 #include "robomongo/core/utils/Logger.h"
+#include "robomongo/core/utils/QtUtils.h"
 #include "robomongo/core/utils/StdUtils.h"
 #include "robomongo/gui/AppStyle.h"
 
@@ -43,12 +47,16 @@ namespace Robomongo
         _timeZone(Utc),
         _viewMode(Robomongo::Tree),
         _autocompletionMode(AutocompleteAll),
-        _batchSize(50),
-        _disableConnectionShortcuts(false),
-        _textFontFamily(""),
-        _textFontPointSize(-1),
+        _loadMongoRcJs(false),
+        _minimizeToTray(false),
         _lineNumbers(false),
-        _loadMongoRcJs(false)
+        _disableConnectionShortcuts(false),
+        _batchSize(50),
+        _textFontFamily(""),
+        _textFontPointSize(-1), 
+        _mongoTimeoutSec(10),
+        _shellTimeoutSec(15),
+        _imported(false)
     {
         load();
         LOG_MSG("SettingsManager initialized in " + _configPath, mongo::logger::LogSeverity::Info(), false);
@@ -56,7 +64,7 @@ namespace Robomongo
 
     SettingsManager::~SettingsManager()
     {
-        std::for_each(_connections.begin() ,_connections.end(), stdutils::default_delete<ConnectionSettings *>());
+        std::for_each(_connections.begin(), _connections.end(), stdutils::default_delete<ConnectionSettings *>());
     }
 
     /**
@@ -138,14 +146,11 @@ namespace Robomongo
             _viewMode = Custom; // Default View Mode
         }
 
-        _autoExpand = map.contains("autoExpand") ?
-            map.value("autoExpand").toBool() : true;
-
-        _autoExec = map.contains("autoExec") ?
-            map.value("autoExec").toBool() : true;
-
-        _lineNumbers = map.contains("lineNumbers") ?
-            map.value("lineNumbers").toBool() : false;
+        _autoExpand = map.contains("autoExpand") ? map.value("autoExpand").toBool() : true;
+        _autoExec = map.contains("autoExec") ? map.value("autoExec").toBool() : true;
+        _minimizeToTray = map.contains("minimizeToTray") ? map.value("minimizeToTray").toBool() : false;
+        _lineNumbers = map.contains("lineNumbers") ? map.value("lineNumbers").toBool() : false;
+        _imported = map.contains("imported") ? map.value("imported").toBool() : false;
 
         // 4. Load TimeZone
         int timeZone = map.value("timeZone").toInt();
@@ -179,6 +184,14 @@ namespace Robomongo
         _textFontFamily = map.value("textFontFamily").toString();
         _textFontPointSize = map.value("textFontPointSize").toInt();
 
+        if (map.contains("mongoTimeoutSec")) {
+            _mongoTimeoutSec = map.value("mongoTimeoutSec").toInt();
+        }
+
+        if (map.contains("shellTimeoutSec")) {
+            _shellTimeoutSec = map.value("shellTimeoutSec").toInt();
+        }
+
         // 5. Load connections
         _connections.clear();
 
@@ -186,7 +199,7 @@ namespace Robomongo
         for (QVariantList::iterator it = list.begin(); it != list.end(); ++it) {
             ConnectionSettings *record = new ConnectionSettings();
             record->fromVariant((*it).toMap());
-            _connections.push_back(record);
+            addConnection(record);
         }
 
         _toolbars = map.value("toolbars").toMap();
@@ -205,6 +218,10 @@ namespace Robomongo
         it = _toolbars.find("logs");
         if (_toolbars.end() == it)
             _toolbars["logs"] = false;
+
+        // Load connection settings from previous
+        // versions of Robomongo
+        importPreviousConnections();
     }
 
     /**
@@ -239,6 +256,8 @@ namespace Robomongo
 
         // 8. Save batchSize
         map.insert("batchSize", _batchSize);
+        map.insert("mongoTimeoutSec", _mongoTimeoutSec);
+        map.insert("shellTimeoutSec", _shellTimeoutSec);
 
         // 9. Save style
         map.insert("style", _currentStyle);
@@ -250,16 +269,16 @@ namespace Robomongo
         // 11. Save connections
         QVariantList list;
 
-        for (ConnectionSettingsContainerType::const_iterator it = _connections.begin(); it!=_connections.end(); ++it) {
+        for (ConnectionSettingsContainerType::const_iterator it = _connections.begin(); it != _connections.end(); ++it) {
             QVariantMap rm = (*it)->toVariant().toMap();
             list.append(rm);
         }
 
         map.insert("connections", list);
-
         map.insert("autoExec", _autoExec);
-
+        map.insert("minimizeToTray", _minimizeToTray);
         map.insert("toolbars", _toolbars);
+        map.insert("imported", _imported);
 
         return map;
     }
@@ -277,8 +296,8 @@ namespace Robomongo
      */
     void SettingsManager::removeConnection(ConnectionSettings *connection)
     {
-        ConnectionSettingsContainerType::iterator it = std::find(_connections.begin(),_connections.end(),connection);
-        if (it!=_connections.end()) {
+        ConnectionSettingsContainerType::iterator it = std::find(_connections.begin(), _connections.end(), connection);
+        if (it != _connections.end()) {
             _connections.erase(it);
             delete connection;
         }
@@ -308,4 +327,125 @@ namespace Robomongo
         _toolbars[toolbarName] = visible;
     }
 
+    void SettingsManager::importPreviousConnections() {
+        // Skip when settings already imported
+        if (_imported)
+            return;
+
+        // Load old configuration file (used till version 0.8.5)
+        const QString oldConfigPath = QString("%1/.config/robomongo/robomongo.json").arg(QDir::homePath());
+
+        if (!QFile::exists(oldConfigPath))
+            return;
+
+        QFile f(oldConfigPath);
+        if (!f.open(QIODevice::ReadOnly))
+            return;
+
+        bool ok;
+        QJson::Parser parser;
+        QVariantMap vmap = parser.parse(f.readAll(), &ok).toMap();
+        if (!ok)
+            return;
+
+        QVariantList vconns = vmap.value("connections").toList();
+        for (QVariantList::iterator itconn = vconns.begin(); itconn != vconns.end(); ++itconn) {
+            QVariantMap vconn = (*itconn).toMap();
+
+            ConnectionSettings *conn = new ConnectionSettings();
+            conn->setImported(true);
+            conn->setConnectionName(QtUtils::toStdString(vconn.value("connectionName").toString()));
+            conn->setServerHost(QtUtils::toStdString(vconn.value("serverHost").toString().left(300)));
+            conn->setServerPort(vconn.value("serverPort").toInt());
+            conn->setDefaultDatabase(QtUtils::toStdString(vconn.value("defaultDatabase").toString()));
+
+            // SSH settings
+            if (vconn.contains("sshAuthMethod")) {
+                SshSettings *ssh = conn->sshSettings();
+                ssh->setHost(QtUtils::toStdString(vconn.value("sshHost").toString()));
+                ssh->setUserName(QtUtils::toStdString(vconn.value("sshUserName").toString()));
+                ssh->setPort(vconn.value("sshPort").toInt());
+                ssh->setUserPassword(QtUtils::toStdString(vconn.value("sshUserPassword").toString()));
+                ssh->setPublicKeyFile(QtUtils::toStdString(vconn.value("sshPublicKey").toString()));
+                ssh->setPrivateKeyFile(QtUtils::toStdString(vconn.value("sshPrivateKey").toString()));
+                ssh->setPassphrase(QtUtils::toStdString(vconn.value("sshPassphrase").toString()));
+
+                int auth = vconn.value("sshAuthMethod").toInt();
+                ssh->setEnabled(auth == 1 || auth == 2);
+                ssh->setAuthMethod(auth == 2 ? "publickey" : "password");
+            }
+
+            // SSL settings
+            if (vconn.contains("sshEnabled")) {
+                SslSettings *ssl = conn->sslSettings();
+                ssl->enableSSL(vconn.value("enabled").toBool());
+                ssl->setPemKeyFile(QtUtils::toStdString(vconn.value("sslPemKeyFile").toString()));
+            }
+
+            // Credentials
+            QVariantList vcreds = vconn.value("credentials").toList();
+            for (QVariantList::const_iterator itcred = vcreds.begin(); itcred != vcreds.end(); ++itcred) {
+                QVariantMap vcred = (*itcred).toMap();
+
+                CredentialSettings *cred = new CredentialSettings();
+                cred->setUserName(QtUtils::toStdString(vcred.value("userName").toString()));
+                cred->setUserPassword(QtUtils::toStdString(vcred.value("userPassword").toString()));
+                cred->setDatabaseName(QtUtils::toStdString(vcred.value("databaseName").toString()));
+                cred->setMechanism("MONGODB-CR");
+                cred->setEnabled(vcred.value("enabled").toBool());
+
+                conn->addCredential(cred);
+            }
+
+            // Check that we didn't have similar connection
+            bool matched = false;
+            for (std::vector<ConnectionSettings*>::const_iterator it = _connections.begin(); it != _connections.end(); ++it) {
+                ConnectionSettings *econn = *it;    // Existing connection
+
+                if (conn->serverPort() != econn->serverPort() ||
+                    conn->serverHost() != econn->serverHost() ||
+                    conn->defaultDatabase() != econn->defaultDatabase())
+                    continue;
+
+                CredentialSettings *cred = conn->primaryCredential();
+                CredentialSettings *ecred = econn->primaryCredential();
+                if (cred->databaseName() != ecred->databaseName() ||
+                    cred->userName() != ecred->userName() ||
+                    cred->userPassword() != ecred->userPassword() ||
+                    cred->enabled() != ecred->enabled())
+                    continue;
+
+                SshSettings *ssh = conn->sshSettings();
+                SshSettings *essh = econn->sshSettings();
+                if (ssh->enabled() != essh->enabled() ||
+                    ssh->port() != essh->port() ||
+                    ssh->host() != essh->host() ||
+                    ssh->privateKeyFile() != essh->privateKeyFile() ||
+                    ssh->userPassword() != essh->userPassword() ||
+                    ssh->userName() != essh->userName())
+                    continue;
+
+                matched = true;
+                break;
+            }
+
+            // Import connection only if we didn't find similar one
+            if (!matched)
+                addConnection(conn);
+        }
+
+        // Mark as imported
+        setImported(true);
+    }
+
+    int SettingsManager::importedConnectionsCount() {
+        int count = 0;
+        for (std::vector<ConnectionSettings*>::const_iterator it = _connections.begin(); it != _connections.end(); ++it) {
+            ConnectionSettings *conn = *it;
+            if (conn->imported())
+                ++count;
+        }
+
+        return count;
+    }
 }

src/robomongo/core/settings/SettingsManager.h

@@ -72,7 +72,7 @@ namespace Robomongo
         UUIDEncoding uuidEncoding() const { return _uuidEncoding; }
 
         void setTimeZone(SupportedTimes timeZ) { _timeZone = timeZ; }
-        SupportedTimes timeZone() const { return _timeZone;}
+        SupportedTimes timeZone() const { return _timeZone; }
 
         void setViewMode(ViewMode viewMode) { _viewMode = viewMode; }
         ViewMode viewMode() const { return _viewMode; }
@@ -86,6 +86,9 @@ namespace Robomongo
         void setAutoExec(bool isAutoExec) { _autoExec = isAutoExec; }
         bool autoExec() const { return _autoExec; }
 
+        void setMinimizeToTray(bool isMinimizingToTray) { _minimizeToTray = isMinimizingToTray; }
+        bool minimizeToTray() const { return _minimizeToTray; }
+
         void setLineNumbers(bool showLineNumbers) { _lineNumbers = showLineNumbers; }
         bool lineNumbers() const { return _lineNumbers; }
 
@@ -98,7 +101,7 @@ namespace Robomongo
         void setBatchSize(int batchSize) { _batchSize = batchSize; }
         int batchSize() const { return _batchSize; }
 
-        QString currentStyle() const {return _currentStyle; }
+        QString currentStyle() const { return _currentStyle; }
         void setCurrentStyle(const QString& style);
 
         QString textFontFamily() const { return _textFontFamily; }
@@ -107,43 +110,62 @@ namespace Robomongo
         int textFontPointSize() const { return _textFontPointSize; }
         void setTextFontPointSize(int pointSize);
 
+        int mongoTimeoutSec() const { return _mongoTimeoutSec; }
+        int shellTimeoutSec() const { return _shellTimeoutSec; }
 
+        // True when settings from previous versions of
+        // Robomongo are imported
+        void setImported(bool imported) { _imported = imported; }
+        bool imported() const { return _imported; }
+
+        /**
+         * Returns number of imported connections
+         */
+        int importedConnectionsCount();
     private:
 
         /**
-         * @brief Load settings from the map. Existings settings will be overwritten.
+         * Load settings from the map. Existing settings will be overwritten.
          */
         void loadFromMap(QVariantMap &map);
 
         /**
-         * @brief Save all settings to map.
+         * Save all settings to map.
          */
         QVariantMap convertToMap() const;
 
+        /**
+         * Load connection settings from previous versions of Robomongo
+         */
+        void importPreviousConnections();
+
         /**
          * @brief Version of settings schema currently loaded
          */
         QString _version;
 
-        /**
-         * @brief UUID encoding
-         */
         UUIDEncoding _uuidEncoding;
         SupportedTimes _timeZone;
-        /**
-         * @brief view mode
-         */
         ViewMode _viewMode;
         AutocompletionMode _autocompletionMode;
         bool _loadMongoRcJs;
         bool _autoExpand;
         bool _autoExec;
+        bool _minimizeToTray;
         bool _lineNumbers;
         bool _disableConnectionShortcuts;
         int _batchSize;
         QString _currentStyle;
         QString _textFontFamily;
         int _textFontPointSize;
+
+        int _mongoTimeoutSec;
+        int _shellTimeoutSec;
+
+        // True when settings from previous versions of
+        // Robomongo are imported
+        bool _imported;
+
         /**
          * @brief List of connections
          */

src/robomongo/core/settings/SshSettings.cpp

@@ -7,7 +7,9 @@ namespace Robomongo
     SshSettings::SshSettings() :
         _port(22),
         _authMethod("publickey"),
-        _enabled(false) {
+        _enabled(false),
+        _askPassword(false),
+        _logLevel(1) {
 
     }
 
@@ -27,6 +29,7 @@ namespace Robomongo
         map.insert("passphrase", QtUtils::toQString(passphrase()));
         map.insert("method", QtUtils::toQString(authMethod()));
         map.insert("enabled", enabled());
+        map.insert("askPassword", askPassword());
         return map;
     }
 
@@ -40,5 +43,6 @@ namespace Robomongo
         setPassphrase(QtUtils::toStdString(map.value("passphrase").toString()));
         setAuthMethod(QtUtils::toStdString(map.value("method").toString()));
         setEnabled(map.value("enabled").toBool());
+        setAskPassword(map.value("askPassword").toBool());
     }
 }

src/robomongo/core/settings/SshSettings.h

@@ -22,6 +22,9 @@ namespace Robomongo
         QVariant toVariant() const;
         void fromVariant(const QVariantMap &map);
 
+        /*
+         * Domain or IPv4 or IPv6 address
+         */
         std::string host() const { return _host; }
         void setHost(const std::string &host) { _host = host; }
 
@@ -43,6 +46,7 @@ namespace Robomongo
         std::string passphrase() const { return _passphrase; }
         void setPassphrase(const std::string &passphrase) { _passphrase = passphrase; }
 
+        // "password" or "publickey"
         std::string authMethod() const { return _authMethod.empty() ? "publickey" : _authMethod; }
         void setAuthMethod(const std::string &method) { _authMethod = method; }
 
@@ -53,11 +57,17 @@ namespace Robomongo
         bool enabled() const { return _enabled; }
         void setEnabled(bool enabled) { _enabled = enabled; }
 
+        bool askPassword() const { return _askPassword; }
+        void setAskPassword(bool ask) { _askPassword = ask; }
+
+        std::string askedPassword() const { return _askedPassword; }
+        void setAskedPassword(const std::string &asked) { _askedPassword = asked; }
+
         int logLevel() const { return _logLevel; }
         void setLogLevel(const int logLevel) { _logLevel = logLevel; }
 
     private:
-        std::string _host;
+        std::string _host;  // domain or IPv4/v6
         int _port;
         std::string _userName;
         std::string _userPassword;
@@ -66,11 +76,16 @@ namespace Robomongo
         std::string _passphrase;
         std::string _authMethod; // "password" or "publickey"
 
+        // Should we ask user about password or passphrase
+        // each time when we try to connect
+        bool _askPassword;
+
         /**
          * Flag, indicating whether we should use
          * this SSH tunnel or not.
          */
         bool _enabled;
-        int _logLevel; // this property is not persisted
+        int _logLevel;              // this property is not persisted
+        std::string _askedPassword; // this property is not persisted
     };
 }

src/robomongo/core/settings/SslSettings.cpp

@@ -0,0 +1,49 @@
+#include "robomongo/core/settings/SslSettings.h"
+
+#include "robomongo/core/utils/QtUtils.h"
+
+namespace Robomongo
+{
+    SslSettings::SslSettings() :
+        _sslEnabled(false), _caFile(""), _pemKeyFile(""),  _pemPassPhrase(""), _crlFile(""), 
+        _allowInvalidHostnames(false),  _allowInvalidCertificates(false), _usePemFile(false),
+        _useAdvancedOptions(false), _askPassphrase(false)
+    {}
+
+    SslSettings *SslSettings::clone() const 
+    {
+        SslSettings *cloned = new SslSettings(*this);
+        return cloned;
+    }
+
+    QVariant SslSettings::toVariant() const 
+    {
+        QVariantMap map;
+        map.insert("sslEnabled", sslEnabled());
+        map.insert("caFile", QtUtils::toQString(caFile()));
+        map.insert("usePemFile", usePemFile());
+        map.insert("pemKeyFile", QtUtils::toQString(pemKeyFile()));
+        map.insert("pemPassPhrase", QtUtils::toQString(pemPassPhrase()));
+        map.insert("useAdvancedOptions", useAdvancedOptions());
+        map.insert("crlFile", QtUtils::toQString(crlFile()));
+        map.insert("allowInvalidHostnames", allowInvalidHostnames());
+        map.insert("allowInvalidCertificates", allowInvalidCertificates());
+        map.insert("askPassphrase", askPassphrase());
+
+        return map;
+    }
+
+    void SslSettings::fromVariant(const QVariantMap &map) 
+    {
+        enableSSL(map.value("sslEnabled").toBool());
+        setCaFile(QtUtils::toStdString(map.value("caFile").toString()));
+        setUsePemFile(map.value("usePemFile").toBool());
+        setPemKeyFile(QtUtils::toStdString(map.value("pemKeyFile").toString()));
+        setPemPassPhrase(QtUtils::toStdString(map.value("pemPassPhrase").toString()));
+        setUseAdvancedOptions(map.value("useAdvancedOptions").toBool());
+        setCrlFile(QtUtils::toStdString(map.value("crlFile").toString()));
+        setAllowInvalidHostnames(map.value("allowInvalidHostnames").toBool());
+        setAllowInvalidCertificates(map.value("allowInvalidCertificates").toBool());
+        setAskPassphrase(map.value("askPassphrase").toBool());
+    }
+}

src/robomongo/core/settings/SslSettings.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <QString>
+#include <QVariant>
+#include <QVariantMap>
+
+namespace Robomongo
+{
+    class SslSettings
+    {
+    public:
+        SslSettings();
+
+        /**
+         * Clones credential settings.
+         */
+        SslSettings *clone() const;
+
+        /**
+         * Converts to QVariantMap
+         */
+        QVariant toVariant() const;
+        void fromVariant(const QVariantMap &map);
+
+
+        // Getters for mongo:: SSLGlobalParams related settings
+        std::string pemKeyFile() const { return _pemKeyFile; }
+        std::string caFile() const { return _caFile; }
+        std::string pemPassPhrase() const { return _pemPassPhrase; }
+        std::string crlFile() const { return _crlFile; }
+        bool allowInvalidHostnames() const { return _allowInvalidHostnames; }
+        bool allowInvalidCertificates() const { return _allowInvalidCertificates; }
+ 
+        // Getters for helper SSL settings 
+        bool usePemFile() const { return _usePemFile; }
+        bool useAdvancedOptions() const { return _useAdvancedOptions; }
+        bool askPassphrase() const { return _askPassphrase; }
+
+        // Setters for mongo:: SSLGlobalParams related settings
+        void setPemKeyFile(const std::string &path) { _pemKeyFile = path; }
+        void setCaFile(const std::string &path) { _caFile = path; }
+        void setPemPassPhrase(const std::string &pemPassPhrase) { _pemPassPhrase = pemPassPhrase; }
+        void setCrlFile(const std::string &path) { _crlFile = path; }
+        void setAllowInvalidHostnames(const bool state) { _allowInvalidHostnames = state; }
+        void setAllowInvalidCertificates(const bool state) { _allowInvalidCertificates = state; }
+
+        // Setters for helper SSL settings 
+        void setUsePemFile(const bool state) { _usePemFile = state; }
+        void setUseAdvancedOptions(const bool state) { _useAdvancedOptions = state; }
+        void setAskPassphrase(const bool state) { _askPassphrase = state; }
+
+        /**
+         * Flag, indicating whether we should use
+         * this SSL settings or not.
+         */
+        bool sslEnabled() const { return _sslEnabled; }
+        void enableSSL(bool enabled) { _sslEnabled = enabled; }
+
+    private:
+
+        // mongo:: SSL Global params related settings
+        std::string _caFile;
+        std::string _pemKeyFile;
+        std::string _pemPassPhrase;
+        std::string _crlFile;
+        bool _allowInvalidHostnames;
+        bool _allowInvalidCertificates;
+
+        // Helper settings indirectly effecting what to pass to SSL global params
+        bool _usePemFile;
+        bool _useAdvancedOptions;
+        bool _askPassphrase;
+
+        /**
+         * Flag, indicating whether SSL enabled for related connection
+         */
+        bool _sslEnabled;
+    };
+}

src/robomongo/core/utils/BsonUtils.cpp

@@ -80,23 +80,23 @@ namespace Robomongo
             s << (isArray ? "[" : "{");
             BSONObjIterator i(obj);
             BSONElement e = i.next();
-            if ( !e.eoo() ){
+            if ( !e.eoo() ) {
                 while ( 1 ) {
                     if ( pretty ) {
                         s << '\n';
-                        for( int x = 0; x < pretty; x++ ){
+                        for( int x = 0; x < pretty; x++ ) {
                             s << "    ";
                         }
                     }
                     else {
                         s << " ";
                     }
-                    s << jsonString(e, format, true, pretty?pretty+1:0, uuidEncoding, timeFormat, isArray);
+                    s << jsonString(e, format, true, pretty ? pretty + 1 : 0, uuidEncoding, timeFormat, isArray);
                     e = i.next();
 
                     if (e.eoo()) {
                         s << '\n';
-                        for( int x = 0; x < pretty - 1; x++ ){
+                        for( int x = 0; x < pretty - 1; x++ ) {
                             s << "    ";
                         }
                         s << (isArray ? "]" : "}");
@@ -130,15 +130,21 @@ namespace Robomongo
                 s << "NumberLong(" << elem._numberLong() << ")";
                 break;
             case NumberInt:
+                s << elem._numberInt();
+                break;
             case NumberDouble:
                 {
-                    int sign=0;
+                    int sign = 0;
                     if ( elem.number() >= -std::numeric_limits< double >::max() &&
                             elem.number() <= std::numeric_limits< double >::max() ) {
 
                         // was 16
                         s.precision(std::numeric_limits<double>::digits10);
                         s << elem.number();
+
+                        // Leave trailing zero if needed
+                        if (elem.number() == (long long)elem.number())
+                            s << ".0";
                     }
                     else if (std::isnan(elem.number()) ) {
                         s << "NaN";
@@ -166,7 +172,7 @@ namespace Robomongo
                 break;
             case Object: {
                 BSONObj obj = elem.embeddedObject();
-                s << jsonString(obj, format, pretty, uuidEncoding,timeFormat);
+                s << jsonString(obj, format, pretty, uuidEncoding, timeFormat);
                 }
                 break;
             case mongo::Array: {
@@ -180,7 +186,7 @@ namespace Robomongo
                 if ( !e.eoo() ) {
                     int count = 0;
                     while ( 1 ) {
-                        if( pretty ) {
+                        if ( pretty ) {
                             s << '\n';
                             for( int x = 0; x < pretty; x++ )
                                 s << "    ";
@@ -190,7 +196,7 @@ namespace Robomongo
                             s << "undefined";
                         }
                         else {
-                            s << jsonString(e, format, false, pretty?pretty+1:0, uuidEncoding, timeFormat, true);
+                            s << jsonString(e, format, false, pretty ? pretty + 1 : 0, uuidEncoding, timeFormat, true);
                             e = i.next();
                         }
                         count++;
@@ -260,13 +266,13 @@ namespace Robomongo
             case mongo::Date:
                 {
                     Date_t d = elem.date();
-                    long long ms = d.toMillisSinceEpoch();//static_cast<long long>(d.millis);
+                    long long ms = d.toMillisSinceEpoch(); //static_cast<long long>(d.millis);
                     bool isSupportedDate = miutil::minDate < ms && ms < miutil::maxDate;
 
                     if ( format == Strict )
                         s << "{ \"$date\" : ";
                     else{
-                        if(isSupportedDate){
+                        if (isSupportedDate) {
                             s << "ISODate(";
                         }
                         else{
@@ -275,7 +281,7 @@ namespace Robomongo
                     }
 
                     if ( pretty && isSupportedDate) {
-                        boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
+                        boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
                         boost::posix_time::time_duration diff = boost::posix_time::millisec(ms);
                         boost::posix_time::ptime time = epoch + diff;
                         std::string timestr = miutil::isotimeString(time, true, timeFormat == LocalTime);
@@ -563,13 +569,13 @@ namespace Robomongo
                 con.append(e.fieldName());
                 con.append("\"");
                 con.append(" : ");
-                buildJsonString(e,con,uuid,tz);
+                buildJsonString(e, con, uuid, tz);
                 con.append(", \n");
             }
             con.append("\n}\n\n");
         }
 
-        void buildJsonString(const mongo::BSONElement &elem,std::string &con, UUIDEncoding uuid, SupportedTimes tz)
+        void buildJsonString(const mongo::BSONElement &elem, std::string &con, UUIDEncoding uuid, SupportedTimes tz)
         {
             switch (elem.type())
             {
@@ -578,6 +584,11 @@ namespace Robomongo
                     std::stringstream s;
                     s.precision(std::numeric_limits<double>::digits10);
                     s << elem.Double();
+
+                    // Leave trailing zero if needed
+                    if (elem.Double() == (long long)elem.Double())
+                        s << ".0";
+
                     con.append(s.str());
                 }
                 break;
@@ -626,13 +637,13 @@ namespace Robomongo
                     long long ms = (long long) elem.Date().toMillisSinceEpoch();
                     bool isSupportedDate = miutil::minDate < ms && ms < miutil::maxDate;
 
-                    boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
+                    boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
                     boost::posix_time::time_duration diff = boost::posix_time::millisec(ms);
                     boost::posix_time::ptime time = epoch + diff;
 
                     std::string date;
-                    if(isSupportedDate)
-                        date = miutil::isotimeString(time,false,tz==LocalTime);
+                    if (isSupportedDate)
+                        date = miutil::isotimeString(time, false, tz == LocalTime);
                     else
                         date = boost::lexical_cast<std::string>(ms);
 
@@ -652,7 +663,7 @@ namespace Robomongo
                         case 'g':
                         case 'i':
                         case 'm':
-                            con+=*f;
+                            con += *f;
                         default:
                             break;
                         }
@@ -678,15 +689,15 @@ namespace Robomongo
                 break;
             case NumberInt:
                 {
-                    char num[16]={0};
-                    sprintf(num,"%d",elem.Int());
+                    char num[16] = {0};
+                    sprintf(num, "%d", elem.Int());
                     con.append(num);
                     break;
                 }           
             case bsonTimestamp:
                 {
                     Date_t date = elem.timestampTime();
-                    unsigned long long millis = date.toMillisSinceEpoch();// millis;
+                    unsigned long long millis = date.toMillisSinceEpoch(); // millis;
                     if ((long long)millis >= 0 &&
                         ((long long)millis/1000) < (std::numeric_limits<time_t>::max)()) {
                             con.append(date.toString());
@@ -695,8 +706,8 @@ namespace Robomongo
                 }
             case NumberLong:
                 {
-                    char num[32]={0};
-                    sprintf(num,"%lld",elem.Long());
+                    char num[32] = {0};
+                    sprintf(num, "%lld", elem.Long());
                     con.append(num);
                     break; 
                 }
@@ -706,13 +717,13 @@ namespace Robomongo
             }
         }
 
-        mongo::BSONElement indexOf(const mongo::BSONObj &doc,int index)
+        mongo::BSONElement indexOf(const mongo::BSONObj &doc, int index)
         {
             mongo::BSONObjIterator iterator(doc);
             for (int i = 0; iterator.more(); ++i)
             {
                 mongo::BSONElement element = iterator.next(); 
-                if(i==index){
+                if (i == index) {
                     return element;
                 }
             }
@@ -722,7 +733,7 @@ namespace Robomongo
         int elementsCount(const mongo::BSONObj &doc)
         {
             mongo::BSONObjIterator iterator(doc);
-            int i=0;
+            int i = 0;
             for (; iterator.more(); ++i)
             {
                 iterator.next();                

src/robomongo/core/utils/BsonUtils.h

@@ -100,8 +100,8 @@ namespace Robomongo
 
         const char* BSONTypeToString(mongo::BSONType type, mongo::BinDataType binDataType, UUIDEncoding uuidEncoding);
 
-        void buildJsonString(const mongo::BSONObj &obj,std::string &con, UUIDEncoding uuid, SupportedTimes tz);
-        void buildJsonString(const mongo::BSONElement &elem,std::string &con, UUIDEncoding uuid, SupportedTimes tz);
+        void buildJsonString(const mongo::BSONObj &obj, std::string &con, UUIDEncoding uuid, SupportedTimes tz);
+        void buildJsonString(const mongo::BSONElement &elem, std::string &con, UUIDEncoding uuid, SupportedTimes tz);
 
         mongo::BSONElement indexOf(const mongo::BSONObj &doc, int index);
         int elementsCount(const mongo::BSONObj &doc);

src/robomongo/core/utils/QtUtils.cpp

@@ -38,7 +38,7 @@ namespace Robomongo
 
         void cleanUpThread(QThread *const thread)
         {
-            if (thread&&thread->isRunning()) {
+            if (thread && thread->isRunning()) {
                 //thread->stop();
                 thread->wait();
             }

src/robomongo/gui/AppStyle.h

@@ -20,6 +20,6 @@ namespace Robomongo
         static const QString StyleName;
         virtual void drawControl(ControlElement element, const QStyleOption * option, QPainter * painter, const QWidget * widget) const;
         virtual void drawPrimitive(PrimitiveElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const;
-        virtual QRect subElementRect( SubElement element, const QStyleOption * option, const QWidget * widget=0 ) const;
+        virtual QRect subElementRect( SubElement element, const QStyleOption * option, const QWidget * widget = 0 ) const;
     };
 }

src/robomongo/gui/GuiRegistry.cpp

@@ -38,6 +38,18 @@ namespace Robomongo
         return serverIc;
     }
 
+    const QIcon &GuiRegistry::serverImportedIcon() const
+    {
+        static const QIcon importedIcon = QIcon(":/robomongo/icons/server_imported_16x16.png");
+        return importedIcon;
+    }
+
+    const QIcon &GuiRegistry::replicaSetIcon() const
+    {
+        static const QIcon replicaSetIc(":/robomongo/icons/replica_set_16x16.png");
+        return replicaSetIc;
+    }
+
     const QIcon &GuiRegistry::openIcon() const
     {
         static const QIcon openIc = qApp->style()->standardIcon(QStyle::SP_DialogOpenButton);
@@ -84,14 +96,26 @@ namespace Robomongo
 
     const QIcon &GuiRegistry::maximizeIcon() const
     {
-        static const QIcon maximizeIc = QIcon(":/robomongo/icons/maximize.gif");
+        static const QIcon maximizeIc(":/robomongo/icons/maximize.png");
         return maximizeIc;
     }
 
-    const QIcon &GuiRegistry::maximizeHighlightedIcon() const
+    const QIcon &GuiRegistry::minimizeIcon() const
     {
-        static const QIcon maximizeHighlightedIc = QIcon(":/robomongo/icons/maximize_highlighted_16x16.png");
-        return maximizeHighlightedIc;
+        static const QIcon minimizeIc(":/robomongo/icons/minimize.png");
+        return minimizeIc;
+    }
+
+    const QIcon &GuiRegistry::undockIcon() const
+    {
+        static const QIcon undockIc(":/robomongo/icons/undock.png");
+        return undockIc;
+    }
+
+    const QIcon &GuiRegistry::dockIcon() const
+    {
+        static const QIcon dockIc(":/robomongo/icons/dock.png");
+        return dockIc;
     }
 
     const QIcon &GuiRegistry::textIcon() const
@@ -223,16 +247,28 @@ namespace Robomongo
 
     const QIcon &GuiRegistry::noMarkIcon() const
     {
-        static const QIcon noMarkIc = QIcon(":/robomongo/icons/no_mark_16x16.png");
+        static const QIcon noMarkIc = QIcon(":/robomongo/icons/no_mark_24x24.png");
         return noMarkIc;
     }
 
     const QIcon &GuiRegistry::yesMarkIcon() const
     {
-        static const QIcon yesMarkIc = QIcon(":/robomongo/icons/yes_mark_16x16.png");
+        static const QIcon yesMarkIc = QIcon(":/robomongo/icons/yes_mark_24x24.png");
         return yesMarkIc;
     }
 
+    const QIcon &GuiRegistry::skipMarkIcon() const
+    {
+        static const QIcon skipMarkIc = QIcon(":/robomongo/icons/skip_mark_24x24.png");
+        return skipMarkIc;
+    }
+
+    const QIcon &GuiRegistry::questionMarkIcon() const
+    {
+        static const QIcon questionMarkIc = QIcon(":/robomongo/icons/question_mark_24x24.png");
+        return questionMarkIc;
+    }
+
     const QIcon &GuiRegistry::timeIcon() const
     {
         static const QIcon timeIc = QIcon(":/robomongo/icons/time_16x16.png");
@@ -245,9 +281,21 @@ namespace Robomongo
         return keyIc;
     }
 
+    const QIcon &GuiRegistry::showIcon() const
+    {
+        static const QIcon icon = QIcon(":/robomongo/icons/show_64x64.png");
+        return icon;
+    }
+
+    const QIcon &GuiRegistry::hideIcon() const
+    {
+        static const QIcon icon = QIcon(":/robomongo/icons/hide_64x64.png");
+        return icon;
+    }
+
     const QBrush &GuiRegistry::typeBrush() const
     {
-        static const QBrush typeBrush = QBrush(QColor(150,150, 150));
+        static const QBrush typeBrush = QBrush(QColor(150, 150, 150));
         return typeBrush;
     }
 

src/robomongo/gui/GuiRegistry.h

@@ -17,7 +17,7 @@ namespace Robomongo
         /**
          * @brief Returns single instance of GuiRegistry
          */
-        static GuiRegistry &instance()
+        static GuiRegistry& instance()
         {
             static GuiRegistry _instance;
             return _instance;
@@ -28,52 +28,60 @@ namespace Robomongo
         /**
          * @brief Functions that provide access to various icons
          */
-        const QIcon &serverIcon() const;
-        const QIcon &saveIcon() const;
-        const QIcon &openIcon() const;
-        const QIcon &databaseIcon() const;
-        const QIcon &collectionIcon() const;
-        const QIcon &indexIcon() const;
-        const QIcon &userIcon() const;
-        const QIcon &functionIcon() const;
-        const QIcon &maximizeIcon() const;
-        const QIcon &maximizeHighlightedIcon() const;
-        const QIcon &textIcon() const;
-        const QIcon &textHighlightedIcon() const;
-        const QIcon &treeIcon() const;
-        const QIcon &treeHighlightedIcon() const;
-        const QIcon &tableIcon() const;
-        const QIcon &tableHighlightedIcon() const;
-        const QIcon &customIcon() const;
-        const QIcon &customHighlightedIcon() const;
-        const QIcon &rotateIcon() const;
-        const QIcon &visualIcon() const;
-        const QIcon &folderIcon() const;
-        const QIcon &circleIcon() const;
-        const QIcon &leftIcon() const;
-        const QIcon &rightIcon() const;
-        const QIcon &mongodbIcon() const;
-        const QIcon &connectIcon() const;
-        const QIcon &executeIcon() const;
-        const QIcon &stopIcon() const;
-        const QIcon &mainWindowIcon() const;
-        const QIcon &bsonObjectIcon() const;
-        const QIcon &bsonArrayIcon() const;
-        const QIcon &bsonStringIcon() const;
-        const QIcon &bsonIntegerIcon() const;
-        const QIcon &bsonDoubleIcon() const;
-        const QIcon &bsonDateTimeIcon() const;
-        const QIcon &bsonBinaryIcon() const;
-        const QIcon &bsonNullIcon() const;
-        const QIcon &bsonBooleanIcon() const;
-        const QIcon &noMarkIcon() const;
-        const QIcon &yesMarkIcon() const;
-        const QIcon &timeIcon() const;
-        const QIcon &keyIcon() const;
+        const QIcon& serverIcon() const;
+        const QIcon& serverImportedIcon() const;
+        const QIcon& replicaSetIcon() const;
+        const QIcon& saveIcon() const;
+        const QIcon& openIcon() const;
+        const QIcon& databaseIcon() const;
+        const QIcon& collectionIcon() const;
+        const QIcon& indexIcon() const;
+        const QIcon& userIcon() const;
+        const QIcon& functionIcon() const;
+        const QIcon& maximizeIcon() const;
+        const QIcon& minimizeIcon() const;
+        const QIcon& undockIcon() const;
+        const QIcon& dockIcon() const;
+        const QIcon& textIcon() const;
+        const QIcon& textHighlightedIcon() const;
+        const QIcon& treeIcon() const;
+        const QIcon& treeHighlightedIcon() const;
+        const QIcon& tableIcon() const;
+        const QIcon& tableHighlightedIcon() const;
+        const QIcon& customIcon() const;
+        const QIcon& customHighlightedIcon() const;
+        const QIcon& rotateIcon() const;
+        const QIcon& visualIcon() const;
+        const QIcon& folderIcon() const;
+        const QIcon& circleIcon() const;
+        const QIcon& leftIcon() const;
+        const QIcon& rightIcon() const;
+        const QIcon& mongodbIcon() const;
+        const QIcon& connectIcon() const;
+        const QIcon& executeIcon() const;
+        const QIcon& stopIcon() const;
+        const QIcon& mainWindowIcon() const;
+        const QIcon& bsonObjectIcon() const;
+        const QIcon& bsonArrayIcon() const;
+        const QIcon& bsonStringIcon() const;
+        const QIcon& bsonIntegerIcon() const;
+        const QIcon& bsonDoubleIcon() const;
+        const QIcon& bsonDateTimeIcon() const;
+        const QIcon& bsonBinaryIcon() const;
+        const QIcon& bsonNullIcon() const;
+        const QIcon& bsonBooleanIcon() const;
+        const QIcon& noMarkIcon() const;
+        const QIcon& yesMarkIcon() const;
+        const QIcon& skipMarkIcon() const;
+        const QIcon& questionMarkIcon() const;
+        const QIcon& timeIcon() const;
+        const QIcon& keyIcon() const;
+        const QIcon& showIcon() const;
+        const QIcon& hideIcon() const;
 
-        const QBrush &typeBrush() const;
+        const QBrush& typeBrush() const;
 
-        const QFont &font() const;
+        const QFont& font() const;
     private:
         /**
          * @brief Private, because this is singleton

src/robomongo/gui/MainWindow.cpp

@@ -16,6 +16,8 @@
 #include <QLabel>
 #include <QStatusBar>
 #include <QHBoxLayout>
+#include <QSettings>
+#include <QSystemTrayIcon>
 
 #include <mongo/logger/log_severity.h>
 #include "robomongo/core/settings/SettingsManager.h"
@@ -36,6 +38,7 @@
 #include "robomongo/gui/dialogs/PreferencesDialog.h"
 #include "robomongo/gui/GuiRegistry.h"
 #include "robomongo/gui/AppStyle.h"
+#include "robomongo/gui/widgets/workarea/QueryWidget.h"
 
 namespace
 {
@@ -67,21 +70,30 @@ namespace
         Robomongo::AppRegistry::instance().settingsManager()->save();
     }
 
+    void saveMinimizeToTraySettings(bool isMinimizingToTray)
+    {
+        Robomongo::AppRegistry::instance().settingsManager()->setMinimizeToTray(isMinimizingToTray);
+        Robomongo::AppRegistry::instance().settingsManager()->save();
+    }
+
     void saveLineNumbers(bool showLineNumbers)
     {
         Robomongo::AppRegistry::instance().settingsManager()->setLineNumbers(showLineNumbers);
         Robomongo::AppRegistry::instance().settingsManager()->save();
     }
-}
+} 
+/* End of anonymous namespace */
+
 
 namespace Robomongo
 {
+/* ------ ConnectionMenu ------ */
     class ConnectionMenu : public QMenu
     {
     public:
         ConnectionMenu(QWidget *parent) : QMenu(parent) {}
     protected:
-        virtual void keyPressEvent(QKeyEvent *event)
+        virtual void keyPressEvent(QKeyEvent *event) override
         {
             if (event->key() == Qt::Key_F12) {
                 hide();
@@ -92,11 +104,16 @@ namespace Robomongo
         }
     };
 
+/* ------ MainWindow ------ */
     MainWindow::MainWindow()
         : BaseClass(),
+        _workArea(nullptr),
         _app(AppRegistry::instance().app()),
-        _workArea(NULL),
-        _connectionsMenu(NULL)
+        _connectionsMenu(nullptr),
+#if defined(Q_OS_WIN)
+        _trayIcon(nullptr),
+#endif
+        _allowExit(false)
     {
         QColor background = palette().window().color();
         QString controlKey = "Ctrl";
@@ -134,7 +151,7 @@ namespace Robomongo
         // Exit action
         QAction *exitAction = new QAction("&Exit", this);
         exitAction->setShortcuts(QKeySequence::Quit);
-        VERIFY(connect(exitAction, SIGNAL(triggered()), this, SLOT(close())));
+        VERIFY(connect(exitAction, SIGNAL(triggered()), this, SLOT(exit())));
 
         // Connect action
         _connectAction = new QAction("&Connect...", this);
@@ -165,6 +182,26 @@ namespace Robomongo
         QWidgetAction *connectButtonAction = new QWidgetAction(this);
         connectButtonAction->setDefaultWidget(_connectButton);
 
+        // Tray icon
+    #if defined(Q_OS_WIN)
+        _trayIcon = new QSystemTrayIcon(GuiRegistry::instance().mainWindowIcon());
+        VERIFY(connect(_trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), 
+                       this, SLOT(trayActivated(QSystemTrayIcon::ActivationReason))));
+
+        QAction *trayMinimizeAction = new QAction("Minimize to Tray", _trayIcon);
+        VERIFY(connect(trayMinimizeAction, SIGNAL(triggered()), this, SLOT(toggleMinimize())));
+
+        QAction *trayExitAction = new QAction("Exit", _trayIcon);
+        VERIFY(connect(trayExitAction, SIGNAL(triggered()), this, SLOT(exit())));
+       
+        QMenu *contextMenu = new QMenu();
+        contextMenu->addAction(trayMinimizeAction);
+        contextMenu->addSeparator();
+        contextMenu->addAction(trayExitAction);
+
+        _trayIcon->setContextMenu(contextMenu);
+    #endif
+
         // Orientation action
         _orientationAction = new QAction("&Rotate", this);
         _orientationAction->setShortcut(Qt::Key_F10);
@@ -323,17 +360,17 @@ namespace Robomongo
         AutocompletionMode autocompletionMode = AppRegistry::instance().settingsManager()->autocompletionMode();
 
         // Autocompletion
-        QAction *autocompletionAllAction = new QAction("All",this);
+        QAction *autocompletionAllAction = new QAction("All", this);
         autocompletionAllAction->setCheckable(true);
         autocompletionAllAction->setChecked(autocompletionMode == AutocompleteAll);
         VERIFY(connect(autocompletionAllAction, SIGNAL(triggered()), this, SLOT(setShellAutocompletionAll())));
 
-        QAction *autocompletionNoCollectionNamesAction = new QAction("All (Except Collection Names)",this);
+        QAction *autocompletionNoCollectionNamesAction = new QAction("All (Except Collection Names)", this);
         autocompletionNoCollectionNamesAction->setCheckable(true);
         autocompletionNoCollectionNamesAction->setChecked(autocompletionMode == AutocompleteNoCollectionNames);
         VERIFY(connect(autocompletionNoCollectionNamesAction, SIGNAL(triggered()), this, SLOT(setShellAutocompletionNoCollectionNames())));
 
-        QAction *autocompletionNoneAction = new QAction("None",this);
+        QAction *autocompletionNoneAction = new QAction("None", this);
         autocompletionNoneAction->setCheckable(true);
         autocompletionNoneAction->setChecked(autocompletionMode == AutocompleteNone);
         VERIFY(connect(autocompletionNoneAction, SIGNAL(triggered()), this, SLOT(setShellAutocompletionNone())));
@@ -348,7 +385,7 @@ namespace Robomongo
         autocompletionGroup->addAction(autocompletionNoCollectionNamesAction);
         autocompletionGroup->addAction(autocompletionNoneAction);
 
-        QAction *loadMongoRcJs = new QAction("Load .mongorc.js",this);
+        QAction *loadMongoRcJs = new QAction("Load .mongorc.js", this);
         loadMongoRcJs->setCheckable(true);
         loadMongoRcJs->setChecked(AppRegistry::instance().settingsManager()->loadMongoRcJs());
         VERIFY(connect(loadMongoRcJs, SIGNAL(triggered()), this, SLOT(setLoadMongoRcJs())));
@@ -369,19 +406,27 @@ namespace Robomongo
         VERIFY(connect(showLineNumbers, SIGNAL(triggered()), this, SLOT(toggleLineNumbers())));
         optionsMenu->addAction(showLineNumbers);
 
-        QAction *disabelConnectionShortcuts = new QAction("Disable Connection Shortcuts",this);
+        QAction *disabelConnectionShortcuts = new QAction("Disable Connection Shortcuts", this);
         disabelConnectionShortcuts->setCheckable(true);
         disabelConnectionShortcuts->setChecked(AppRegistry::instance().settingsManager()->disableConnectionShortcuts());
         VERIFY(connect(disabelConnectionShortcuts, SIGNAL(triggered()), this, SLOT(setDisableConnectionShortcuts())));
         optionsMenu->addAction(disabelConnectionShortcuts);
         
-        QAction *autoExec = new QAction(tr("Automatically execute code in new tab"),this);
+        QAction *autoExec = new QAction(tr("Automatically execute code in new tab"), this);
         autoExec->setCheckable(true);
         autoExec->setChecked(AppRegistry::instance().settingsManager()->autoExec());
         VERIFY(connect(autoExec, SIGNAL(triggered()), this, SLOT(toggleAutoExec())));
         optionsMenu->addAction(autoExec);
 
-        QAction *preferencesAction = new QAction("Preferences",this);
+    #if defined(Q_OS_WIN)
+        QAction *minimizeTray = new QAction("Close button should minimize to system tray");
+        minimizeTray->setCheckable(true);
+        minimizeTray->setChecked(AppRegistry::instance().settingsManager()->minimizeToTray());
+        VERIFY(connect(minimizeTray, SIGNAL(triggered()), this, SLOT(toggleMinimizeToTray())));
+        optionsMenu->addAction(minimizeTray);
+    #endif
+
+        QAction *preferencesAction = new QAction("Preferences", this);
         VERIFY(connect(preferencesAction, SIGNAL(triggered()), this, SLOT(openPreferences())));
         preferencesAction->setVisible(false);
         optionsMenu->addAction(preferencesAction);
@@ -504,6 +549,12 @@ namespace Robomongo
         AppRegistry::instance().bus()->subscribe(this, ScriptExecutedEvent::Type);
         AppRegistry::instance().bus()->subscribe(this, ScriptExecutingEvent::Type);
         AppRegistry::instance().bus()->subscribe(this, QueryWidgetUpdatedEvent::Type);
+        AppRegistry::instance().bus()->subscribe(this, OperationFailedEvent::Type);
+
+        restoreWindowsSettings();
+
+        // Catch application windows focus changes
+        VERIFY(connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(on_focusChanged())));
     }
 
     void MainWindow::createStylesMenu()
@@ -516,7 +567,7 @@ namespace Robomongo
          const QString &currentStyle = AppRegistry::instance().settingsManager()->currentStyle();
          for (QStringList::const_iterator it = supportedStyles.begin(); it != supportedStyles.end(); ++it) {
              const QString &style = *it;
-             QAction *styleAction = new QAction(style,this);
+             QAction *styleAction = new QAction(style, this);
              styleAction->setCheckable(true);
              styleAction->setChecked(style == currentStyle);
              styleGroup->addAction(styleAction);
@@ -565,6 +616,43 @@ namespace Robomongo
         AppRegistry::instance().settingsManager()->save();
     }
 
+    void MainWindow::exit()
+    {
+        _allowExit = true;
+        close();
+    }
+
+    void MainWindow::restoreWindowsSettings()
+    {
+        QSettings settings("Paralect", "Robomongo");
+        // Restore settings if registery key exists, otherwise resize as app started for the first time.
+        if (settings.contains("MainWindow/geometry"))
+        {
+            restoreGeometry(settings.value("MainWindow/geometry").toByteArray());
+        }
+        else
+        {
+            // Resize main window. We are trying to keep it "almost" maximized.
+            QRect screenGeometry = QApplication::desktop()->availableGeometry();
+            int horizontalMargin = (int)(screenGeometry.width() * 0.1);     // todo: use C++ static cast instead of C-style cast
+            int verticalMargin = (int)(screenGeometry.height() * 0.1);
+            int _width = screenGeometry.width() - horizontalMargin;
+            int _height = screenGeometry.height() - verticalMargin;
+            resize(QSize(_width, _height));
+
+            // Center main window
+            int x = (screenGeometry.width() - width()) / 2;
+            int y = (screenGeometry.height() - height()) / 2;
+            move(x, y);
+        }
+    }
+
+    void MainWindow::saveWindowsSettings() const
+    {
+        QSettings settings("Paralect", "Robomongo");
+        settings.setValue("MainWindow/geometry", saveGeometry());
+    }
+
     void MainWindow::open()
     {
         QueryWidget *wid = _workArea->currentQueryWidget();
@@ -598,23 +686,13 @@ namespace Robomongo
         }
     }
 
-    void MainWindow::keyPressEvent(QKeyEvent *event)
-    {
-        if (event->key() == Qt::Key_F12) {
-           _connectButton->showMenu();
-            return;
-        }
-
-        BaseClass::keyPressEvent(event);
-    }
-
     void MainWindow::updateConnectionsMenu()
     {
         _connectionsMenu->clear();
         int number = 1;
         // Populate list with connections
         SettingsManager::ConnectionSettingsContainerType connections = AppRegistry::instance().settingsManager()->connections();
-        for(SettingsManager::ConnectionSettingsContainerType::const_iterator it = connections.begin(); it!= connections.end(); ++it) {
+        for (SettingsManager::ConnectionSettingsContainerType::const_iterator it = connections.begin(); it != connections.end(); ++it) {
             ConnectionSettings *connection = *it;
             QAction *action = new QAction(QtUtils::toQString(connection->getReadableName()), this);
             action->setData(QVariant::fromValue(connection));
@@ -641,8 +719,14 @@ namespace Robomongo
 
     void MainWindow::manageConnections()
     {
-        ConnectionsDialog dialog(AppRegistry::instance().settingsManager(), this);
+    #if defined(Q_OS_WIN)
+        _trayIcon->hide(); // hide the tray icon so the main window can't be hidden behind the connections dialog
+    #endif
+
+        static bool checkForImported = true;
+        ConnectionsDialog dialog(AppRegistry::instance().settingsManager(), checkForImported, this);
         int result = dialog.exec();
+        checkForImported = false;
 
         // save settings and update connection menu
         AppRegistry::instance().settingsManager()->save();
@@ -663,13 +747,17 @@ namespace Robomongo
             }
 
             try {
-                _app->openServer(selected, true);
+                _app->openServer(selected, ConnectionPrimary);
             } catch(const std::exception &) {
                 QString message = QString("Cannot connect to MongoDB (%1)").arg(QtUtils::toQString(selected->getFullAddress()));
                 QMessageBox::information(this, "Error", message);
             }
         }
 
+    #if defined(Q_OS_WIN)
+        _trayIcon->show(); // show the tray icon once the connections dialog is gone
+    #endif
+
         // on linux focus is lost - we need to activate main window back
         activateWindow();
     }
@@ -788,7 +876,7 @@ namespace Robomongo
 
     void MainWindow::refreshConnections()
     {
-        QToolTip::showText(QPoint(0,0),
+        QToolTip::showText(QPoint(0, 0),
         QString("Refresh not working yet... : <br/>  <b>Ctrl+D</b> : push Button"));
     }
 
@@ -883,7 +971,7 @@ namespace Robomongo
         QVariant data = connectionAction->data();
         ConnectionSettings *ptr = data.value<ConnectionSettings *>();
         try {
-            _app->openServer(ptr, true);
+            _app->openServer(ptr, ConnectionPrimary);
         }
         catch(const std::exception &) {
             QString message = QString("Cannot connect to the MongoDB at %1.")
@@ -894,6 +982,18 @@ namespace Robomongo
 
     void MainWindow::handle(ConnectionFailedEvent *event)
     {
+        // Handle only Primary connections
+        if (event->connectionType != ConnectionPrimary)
+            return;
+
+
+        // Very temporary solution to prevent multiple connection error messages
+        // from both SshTunnelWorker and MongoWorker
+        static int lastServerHandle = -1;
+        if (event->serverHandle <= lastServerHandle)
+            return;
+
+        lastServerHandle = event->serverHandle;
         QMessageBox::information(this, "Error", QtUtils::toQString(event->message));
     }
 
@@ -909,6 +1009,62 @@ namespace Robomongo
         _executeAction->setDisabled(false);
     }
 
+    void MainWindow::handle(OperationFailedEvent *event)
+    {
+        std::stringstream ss;
+        ss << event->userFriendlyErrorMessage << std::endl << std::endl
+            << "Error:" << std::endl << event->technicalErrorMessage;
+
+        QMessageBox::information(NULL, "Operation failed", QtUtils::toQString(ss.str()));
+    }
+
+    void MainWindow::keyPressEvent(QKeyEvent *event)
+    {
+        if (event->key() == Qt::Key_F12) {
+            _connectButton->showMenu();
+            return;
+        }
+
+        BaseClass::keyPressEvent(event);
+    }
+
+    void MainWindow::closeEvent(QCloseEvent *event)
+    {
+        saveWindowsSettings();
+    #if defined(Q_OS_WIN)
+        if (AppRegistry::instance().settingsManager()->minimizeToTray() && !_allowExit) {
+            event->ignore();
+            hide(); // hide the window because it can be reopened with the tray icon
+        }
+        else {
+            if (_trayIcon->isVisible())
+                _trayIcon->hide();
+
+            QMainWindow::closeEvent(event);
+        }
+    #else
+        QMainWindow::closeEvent(event);
+    #endif
+    }
+
+    void MainWindow::hideEvent(QHideEvent *event)
+    {
+#if defined(Q_OS_WIN)
+        if (_trayIcon->contextMenu()->actions().size() > 0 && isHidden()) {
+            _trayIcon->contextMenu()->actions().at(0)->setText("Show Robomongo");
+        }
+#endif
+    }
+    
+    void MainWindow::showEvent(QShowEvent *event)
+    {
+#if defined(Q_OS_WIN)
+        if (_trayIcon->contextMenu()->actions().size() > 0) {
+            _trayIcon->contextMenu()->actions().at(0)->setText("Minimize to Tray");
+        }
+#endif
+    }
+
     void MainWindow::handle(QueryWidgetUpdatedEvent *event)
     {
         _orientationAction->setEnabled(event->numOfResults() > 1);
@@ -950,7 +1106,7 @@ namespace Robomongo
         _logDock = new QDockWidget(tr("Logs"));
         _logDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea | Qt::TopDockWidgetArea);
         _logDock->setWidget(log);
-        _logDock->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable);
+        _logDock->setFeatures(QDockWidget::DockWidgetClosable);
         _logDock->setVisible(false);
 
         QAction *action = _logDock->toggleViewAction();
@@ -980,6 +1136,7 @@ namespace Robomongo
         _workArea = new WorkAreaTabWidget(this);
         AppRegistry::instance().bus()->subscribe(_workArea, OpeningShellEvent::Type);
         VERIFY(connect(_workArea, SIGNAL(currentChanged(int)), this, SLOT(updateMenus())));
+        VERIFY(connect(_workArea, SIGNAL(currentChanged(int)), this, SLOT(on_tabChange())));
 
         QHBoxLayout *hlayout = new QHBoxLayout;
         hlayout->setContentsMargins(0, 3, 0, 0);
@@ -1013,4 +1170,44 @@ namespace Robomongo
         AppRegistry::instance().settingsManager()->setToolbarSettings("explorer", isVisible);
         AppRegistry::instance().settingsManager()->save();
     }
+
+    void MainWindow::on_tabChange()
+    {
+        auto activeTab = dynamic_cast<QueryWidget*>(_workArea->currentWidget());
+        if (activeTab) {
+            activeTab->bringDockToFront();
+        }
+    }
+
+    void MainWindow::toggleMinimize()
+    {
+        if (isHidden()) {
+            show();
+        }
+        else {
+            hide();
+        }
+    }
+
+    void MainWindow::trayActivated(QSystemTrayIcon::ActivationReason reason)
+    {
+        if (QSystemTrayIcon::DoubleClick == reason && isHidden()) {
+            show();
+        }
+    }
+
+    void MainWindow::toggleMinimizeToTray()
+    {
+        QAction *send = qobject_cast<QAction*>(sender());
+        saveMinimizeToTraySettings(send->isChecked());
+    }
+
+    void MainWindow::on_focusChanged()
+    {
+        // If focus is on floating output window, make it's parent (which is a QueryWidget tab) as active tab
+        auto const activeDock = dynamic_cast<QueryWidget::CustomDockWidget*>(qApp->activeWindow());
+        if (activeDock) {
+            _workArea->setCurrentWidget(activeDock->getParentQueryWidget());
+        }
+    }
 }

src/robomongo/gui/MainWindow.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <QMainWindow>
+#include <QSystemTrayIcon>
 QT_BEGIN_NAMESPACE
 class QLabel;
 class QToolBar;
@@ -13,6 +14,8 @@ namespace Robomongo
     class ConnectionFailedEvent;
     class ScriptExecutingEvent;
     class ScriptExecutedEvent;
+    class OperationFailedEvent;
+
     class QueryWidgetUpdatedEvent;
     class WorkAreaTabWidget;
     class ConnectionMenu;
@@ -25,7 +28,6 @@ namespace Robomongo
     public:
         typedef QMainWindow BaseClass;
         MainWindow();
-        void keyPressEvent(QKeyEvent *event);
 
     public Q_SLOTS:
         void manageConnections();
@@ -49,6 +51,7 @@ namespace Robomongo
         void save();
         void saveAs();
         void changeStyle(QAction *);
+        void exit();
 
         void setDefaultUuidEncoding();
         void setJavaUuidEncoding();
@@ -66,6 +69,14 @@ namespace Robomongo
         void handle(ScriptExecutingEvent *event);
         void handle(ScriptExecutedEvent *event);
         void handle(QueryWidgetUpdatedEvent *event);
+        void handle(OperationFailedEvent *event);
+
+    protected:
+        void keyPressEvent(QKeyEvent *event) override;
+        void closeEvent(QCloseEvent *event) override;
+        void hideEvent(QHideEvent *event) override;
+        void showEvent(QShowEvent *event) override;
+
     private Q_SLOTS:
         void updateMenus();
         void setUtcTimeZone();
@@ -76,8 +87,24 @@ namespace Robomongo
         void onOpenSaveToolbarVisibilityChanged(bool isVisisble);
         void onExecToolbarVisibilityChanged(bool isVisisble);
         void onExplorerVisibilityChanged(bool isVisisble);
+        void on_tabChange();
+
+        void toggleMinimize();
+        void trayActivated(QSystemTrayIcon::ActivationReason reason);
+        void toggleMinimizeToTray();
+
+        // On application focus changes
+        void on_focusChanged();
 
     private:
+        void updateConnectionsMenu();
+        void createDatabaseExplorer();
+        void createTabs();
+        void createStylesMenu();
+        void createStatusBar();
+        void restoreWindowsSettings();
+        void saveWindowsSettings() const;
+
         QDockWidget *_logDock;
 
         WorkAreaTabWidget *_workArea;
@@ -97,11 +124,11 @@ namespace Robomongo
         QAction *_orientationAction;
         QToolBar *_execToolBar;
 
-        void updateConnectionsMenu();
-        void createDatabaseExplorer();
-        void createTabs();
-        void createStylesMenu();
-        void createStatusBar();
+#if defined(Q_OS_WIN)
+        QSystemTrayIcon *_trayIcon;
+#endif
+
+        bool _allowExit;
     };
 
 }

src/robomongo/gui/dialogs/AboutDialog.cpp

@@ -19,11 +19,17 @@ namespace
         "<br/>"
         "<a href=\"https://" PROJECT_GITHUB_FORK "\">Fork</a> project or <a href=\"https://" PROJECT_GITHUB_ISSUES "\">submit</a> issues/proposals on GitHub.  <br/>"
         "<br/>"
-        "Copyright 2013-2016 <a href=\"http:// " PROJECT_COMPANYNAME_DOMAIN "\">" PROJECT_COMPANYNAME "</a>. All rights reserved.<br/>"
+        "Copyright 2013-2016 <a href=\"http://" PROJECT_COMPANYNAME_DOMAIN "\">" PROJECT_COMPANYNAME "</a>. All rights reserved.<br/>"
         "<br/>"
         "The program is provided AS IS with NO WARRANTY OF ANY KIND, "
         "INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A "
-        "PARTICULAR PURPOSE.<br/>");
+        "PARTICULAR PURPOSE.<br/>"
+        "<br>"
+        "Credits: "
+        "<br/>"
+        "Some icons are designed by Freepik from <a href=http://www.flaticon.com>www.flaticon.com</a>"
+        "<br/>"
+        );
 }
 
 namespace Robomongo

src/robomongo/gui/dialogs/ConnectionAuthTab.cpp

@@ -10,6 +10,8 @@
 #include "robomongo/core/settings/ConnectionSettings.h"
 #include "robomongo/core/settings/CredentialSettings.h"
 #include "robomongo/core/utils/QtUtils.h"
+#include "robomongo/gui/GuiRegistry.h"
+#include "robomongo/gui/utils/GuiConstants.h"
 
 namespace Robomongo
 {
@@ -43,7 +45,17 @@ namespace Robomongo
         _useAuth->setStyleSheet("margin-bottom: 7px");
         VERIFY(connect(_useAuth, SIGNAL(toggled(bool)), this, SLOT(authChecked(bool))));
 
-        _echoModeButton = new QPushButton("Show");
+        _echoModeButton = new QPushButton;
+        _echoModeButton->setIcon(GuiRegistry::instance().hideIcon());
+#ifdef Q_OS_MAC
+        _echoModeButton->setMaximumWidth(50);
+#else
+        _echoModeButton->setMinimumWidth(50);
+#endif
+        // Attempt to fix the issue for Windows High DPI button height is slightly taller than other widgets 
+#ifdef Q_OS_WIN
+        _echoModeButton->setMaximumHeight(HighDpiContants::WIN_HIGH_DPI_BUTTON_HEIGHT);
+#endif
         VERIFY(connect(_echoModeButton, SIGNAL(clicked()), this, SLOT(toggleEchoMode())));
 
         _useAuth->setChecked(_settings->hasEnabledPrimaryCredential());
@@ -57,23 +69,20 @@ namespace Robomongo
             _mechanismComboBox->setCurrentText(QtUtils::toQString(primaryCredential->mechanism()));
         }
 
-        QGridLayout *_authLayout = new QGridLayout;
-        _authLayout->addWidget(_useAuth,                      0, 0, 1, 3);
-        _authLayout->addWidget(_databaseNameLabel,            1, 0);
-        _authLayout->addWidget(_databaseName,                 1, 1, 1, 2);
-        _authLayout->addWidget(_databaseNameDescriptionLabel, 2, 1, 1, 2);
-        _authLayout->addWidget(_userNameLabel,                3, 0);
-        _authLayout->addWidget(_userName,                     3, 1, 1, 2);
-        _authLayout->addWidget(_userPasswordLabel,            4, 0);
-        _authLayout->addWidget(_userPassword,                 4, 1);
-        _authLayout->addWidget(_echoModeButton,               4, 2);
-        _authLayout->addWidget(_mechanismLabel,               5, 0);
-        _authLayout->addWidget(_mechanismComboBox,            5, 1, 1, 2);
-        _authLayout->setAlignment(Qt::AlignTop);
-
-        QVBoxLayout *mainLayout = new QVBoxLayout;
-        mainLayout->addLayout(_authLayout);
-        setLayout(mainLayout);
+        QGridLayout *authLayout = new QGridLayout;
+        authLayout->addWidget(_useAuth,                      0, 0, 1, 3);
+        authLayout->addWidget(_databaseNameLabel,            1, 0);
+        authLayout->addWidget(_databaseName,                 1, 1, 1, 2);
+        authLayout->addWidget(_databaseNameDescriptionLabel, 2, 1, 1, 2);
+        authLayout->addWidget(_userNameLabel,                3, 0);
+        authLayout->addWidget(_userName,                     3, 1, 1, 2);
+        authLayout->addWidget(_userPasswordLabel,            4, 0);
+        authLayout->addWidget(_userPassword,                 4, 1);
+        authLayout->addWidget(_echoModeButton,               4, 2);
+        authLayout->addWidget(_mechanismLabel,               5, 0);
+        authLayout->addWidget(_mechanismComboBox,            5, 1, 1, 2);
+        authLayout->setAlignment(Qt::AlignTop);
+        setLayout(authLayout);
     }
 
     void ConnectionAuthTab::accept()
@@ -99,7 +108,7 @@ namespace Robomongo
     {
         bool isPassword = _userPassword->echoMode() == QLineEdit::Password;
         _userPassword->setEchoMode(isPassword ? QLineEdit::Normal: QLineEdit::Password);
-        _echoModeButton->setText(isPassword ? "Hide": "Show");
+        _echoModeButton->setIcon(isPassword ? GuiRegistry::instance().showIcon() : GuiRegistry::instance().hideIcon());
     }
 
     void ConnectionAuthTab::authChecked(bool checked)

src/robomongo/gui/dialogs/ConnectionBasicTab.cpp

@@ -7,54 +7,172 @@
 #include <QCheckBox>
 #include <QPushButton>
 #include <QFileDialog>
+#include <QComboBox>
+#include <QListWidget>
+#include <QListWidgetItem>
 
 #include "robomongo/core/utils/QtUtils.h"
 #include "robomongo/core/settings/ConnectionSettings.h"
+#include "robomongo/core/settings/ReplicaSetSettings.h"
 
 namespace Robomongo
 {
     ConnectionBasicTab::ConnectionBasicTab(ConnectionSettings *settings) :
         _settings(settings)
     {
-        QLabel *connectionDescriptionLabel = new QLabel(
-            "Choose any connection name that will help you to identify this connection.");
-        connectionDescriptionLabel->setWordWrap(true);
-        connectionDescriptionLabel->setContentsMargins(0, -2, 0, 20);
-
-        QLabel *serverDescriptionLabel = new QLabel(
-            "Specify host and port of MongoDB server. Host can be either IPv4, IPv6 or domain name.");
-        serverDescriptionLabel->setWordWrap(true);
-        serverDescriptionLabel->setContentsMargins(0, -2, 0, 20);
+        const ReplicaSetSettings* const replicaSettings = _settings->replicaSetSettings();
 
+        _typeLabel = new QLabel("Type:");
+        _connectionType = new QComboBox;
+        _connectionType->addItem(tr("Direct Connection"));
+        _connectionType->addItem(tr("Replica Set or Sharded Cluster")); 
+        _connectionType->setCurrentIndex(static_cast<int>(_settings->isReplicaSet()));
+        VERIFY(connect(_connectionType, SIGNAL(currentIndexChanged(int)), this, SLOT(on_ConnectionTypeChange(int))));
+        
+        _nameLabel = new QLabel("Name:"); 
         _connectionName = new QLineEdit(QtUtils::toQString(_settings->connectionName()));
+        _connInfoLabel = new QLabel("Choose any connection name that will help you to identify this connection.");
+        _connInfoLabel->setWordWrap(true);
+        _connInfoLabel->setContentsMargins(0, -2, 0, 20);
+
+        _addressLabel = new QLabel("Address:");
         _serverAddress = new QLineEdit(QtUtils::toQString(_settings->serverHost()));
+        _colon = new QLabel(":");
         _serverPort = new QLineEdit(QString::number(_settings->serverPort()));
         _serverPort->setFixedWidth(80);
-        QRegExp rx("\\d+");//(0-65554)
-        _serverPort->setValidator(new QRegExpValidator(rx, this));
+        QRegExp rx("\\d+"); //(0-65554)
+        _serverPort->setValidator(new QRegExpValidator(rx, this)); 
+        _addInfoLabel = new QLabel("Specify host and port of MongoDB server. Host can be either IPv4, IPv6 or domain name.");
+        _addInfoLabel->setWordWrap(true);
+        _addInfoLabel->setContentsMargins(0, -2, 0, 20);
 
+        _membersLabel = new QLabel("Members:");
+        _members = new QListWidget;
+        if (_settings->isReplicaSet()) 
+        {
+            if (replicaSettings->members().empty()) 
+            {
+                auto item = new QListWidgetItem("localhost:27017");
+                item->setFlags(item->flags() | Qt::ItemIsEditable);
+                _members->addItem(item);
+            }
+            else            
+            {
+                for (const std::string& str : replicaSettings->members()) 
+                {
+                    auto item = new QListWidgetItem(QString::fromStdString(str));
+                    item->setFlags(item->flags() | Qt::ItemIsEditable);
+                    _members->addItem(item);
+                }
+            }
+        }
+
+        int const BUTTON_SIZE = 60;
+        _addButton = new QPushButton("Add");
+        _addButton->setFixedWidth(BUTTON_SIZE);
+        _removeButton = new QPushButton("Remove");
+        _removeButton->setFixedWidth(BUTTON_SIZE);
+        _discoverButton = new QPushButton("Discover");
+        _discoverButton->setFixedWidth(BUTTON_SIZE);
+        VERIFY(connect(_addButton, SIGNAL(clicked()), this, SLOT(on_addButton_clicked())));
+
+        auto hLayout = new QHBoxLayout;
+        hLayout->addWidget(_addButton);
+        hLayout->addWidget(_removeButton);
+        hLayout->addWidget(_discoverButton);
+        hLayout->setAlignment(Qt::AlignRight);
+
+        _readPrefLabel = new QLabel("Read Preference:");
+        _readPrefLabel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
+        _readPreference = new QComboBox;
+        _readPreference->addItems(QStringList({ "Primary", "Primary Preferred" }));  //todo
+        if (_settings->isReplicaSet()) {
+            _readPreference->setCurrentIndex(static_cast<int>(replicaSettings->readPreference()));
+        }
+        
         QGridLayout *connectionLayout = new QGridLayout;
         connectionLayout->setAlignment(Qt::AlignTop);
-        connectionLayout->addWidget(new QLabel("Name:"),          1, 0);
-        connectionLayout->addWidget(_connectionName,              1, 1, 1, 3);
-        connectionLayout->addWidget(connectionDescriptionLabel,   2, 1, 1, 3);
-        connectionLayout->addWidget(new QLabel("Address:"),       3, 0);
-        connectionLayout->addWidget(_serverAddress,               3, 1);
-        connectionLayout->addWidget(new QLabel(":"),              3, 2);
-        connectionLayout->addWidget(_serverPort,                  3, 3);
-        connectionLayout->addWidget(serverDescriptionLabel,       4, 1, 1, 3);
+        //// Temporarily disable Replica Set - feature is under development
+        //connectionLayout->addWidget(_typeLabel,                     1, 0);
+        //connectionLayout->addWidget(_connectionType,                1, 1, 1, 3);        
+        //connectionLayout->addWidget(new QLabel(""),                 2, 0);
+        connectionLayout->addWidget(_nameLabel,                     3, 0);
+        connectionLayout->addWidget(_connectionName,                3, 1, 1, 3);
+        connectionLayout->addWidget(_connInfoLabel,                 4, 1, 1, 3);
+        connectionLayout->addWidget(_addressLabel,                  5, 0);
+        connectionLayout->addWidget(_serverAddress,                 5, 1);
+        connectionLayout->addWidget(_colon,                         5, 2);
+        connectionLayout->addWidget(_serverPort,                    5, 3);
+        connectionLayout->addWidget(_addInfoLabel,                  6, 1, 1, 3);
+        connectionLayout->addWidget(_membersLabel,                  7, 0, Qt::AlignTop);
+        connectionLayout->addWidget(_members,                       7, 1, 1, 3);        
+        connectionLayout->addLayout(hLayout,                        8, 1, 1, 3, Qt::AlignRight);
+        connectionLayout->addWidget(new QLabel(""),                 9, 0);
+        connectionLayout->addWidget(_readPrefLabel,                 10, 0);
+        connectionLayout->addWidget(_readPreference,                10, 1, 1, 3);        
+        connectionLayout->addWidget(new QLabel(""),                 11, 0);
 
         QVBoxLayout *mainLayout = new QVBoxLayout;
         mainLayout->addLayout(connectionLayout);
         setLayout(mainLayout);
 
         _connectionName->setFocus();
+        on_ConnectionTypeChange(_connectionType->currentIndex());
     }
 
     void ConnectionBasicTab::accept()
     {
+        ReplicaSetSettings* const replicaSettings = _settings->replicaSetSettings();
+       
+        _settings->setReplicaSet(static_cast<bool>(_connectionType->currentIndex()));
         _settings->setConnectionName(QtUtils::toStdString(_connectionName->text()));
         _settings->setServerHost(QtUtils::toStdString(_serverAddress->text()));
         _settings->setServerPort(_serverPort->text().toInt());
+        if (_settings->isReplicaSet()) {
+            // save replica members
+            std::vector<std::string> members;
+            for (int i = 0; i < _members->count(); ++i)
+            {
+                QListWidgetItem const* item = _members->item(i);
+                members.push_back(item->text().toStdString());
+            }
+            replicaSettings->setMembers(members);
+            // save read preference option 
+            replicaSettings->setReadPreference(
+                static_cast<ReplicaSetSettings::ReadPreference>(_readPreference->currentIndex()));
+        }
+    }
+
+    void ConnectionBasicTab::on_ConnectionTypeChange(int index)
+    {
+        bool const isReplica = static_cast<bool>(index);
+        
+        // Replica set
+        _membersLabel->setVisible(isReplica);
+        _members->setVisible(isReplica);
+        _addButton->setVisible(isReplica);
+        _removeButton->setVisible(isReplica);
+        _discoverButton->setVisible(isReplica);
+        _readPrefLabel->setVisible(isReplica);
+        _readPreference->setVisible(isReplica);
+        
+        // Direct Connection
+        _addressLabel->setVisible(!isReplica);
+        _serverAddress->setVisible(!isReplica);
+        _serverPort->setVisible(!isReplica);
+        _colon->setVisible(!isReplica);
+        _addInfoLabel->setVisible(!isReplica);
+    }
+
+    void ConnectionBasicTab::deleteItem()
+    {
+        delete _members->currentItem(); // todo: refactor
+    }
+
+    void ConnectionBasicTab::on_addButton_clicked()
+    {
+        auto item = new QListWidgetItem("localhost:27017");
+        item->setFlags(item->flags() | Qt::ItemIsEditable);
+        _members->addItem(item);
     }
 }

src/robomongo/gui/dialogs/ConnectionBasicTab.h

@@ -3,8 +3,11 @@
 #include <QWidget>
 QT_BEGIN_NAMESPACE
 class QLineEdit;
+class QLabel;
 class QCheckBox;
 class QPushButton;
+class QComboBox;
+class QListWidget;
 QT_END_NAMESPACE
 
 namespace Robomongo
@@ -19,10 +22,30 @@ namespace Robomongo
         ConnectionBasicTab(ConnectionSettings *settings);
         void accept();
 
+    private Q_SLOTS:
+        void on_ConnectionTypeChange(int index);
+        void deleteItem();
+        void on_addButton_clicked();
+
     private:
+        QLabel *_typeLabel;
+        QComboBox *_connectionType;
+        QLabel *_nameLabel;
         QLineEdit *_connectionName;
+        QLabel *_connInfoLabel;
+        QLabel *_addressLabel;
         QLineEdit *_serverAddress;
+        QLabel *_colon;
         QLineEdit *_serverPort;
+        QLabel *_addInfoLabel;
+        QLabel *_membersLabel;
+        QListWidget *_members;
+        QPushButton *_addButton;
+        QPushButton *_removeButton;
+        QPushButton *_discoverButton;
+        QLabel *_readPrefLabel;
+        QComboBox *_readPreference;
+
         ConnectionSettings *const _settings;
     };
 }

src/robomongo/gui/dialogs/ConnectionDiagnosticDialog.cpp

@@ -5,169 +5,275 @@
 #include <QLabel>
 #include <QPushButton>
 #include <QMovie>
+#include <QMessageBox>
 
-#include <boost/scoped_ptr.hpp>
-#include <mongo/client/dbclientinterface.h>
 #include "robomongo/core/settings/ConnectionSettings.h"
 #include "robomongo/core/settings/CredentialSettings.h"
+#include "robomongo/core/settings/SshSettings.h"
+#include "robomongo/core/settings/SslSettings.h"
 #include "robomongo/gui/GuiRegistry.h"
+#include "robomongo/core/AppRegistry.h"
+#include "robomongo/core/domain/App.h"
+#include "robomongo/core/domain/MongoServer.h"
+#include "robomongo/core/EventBus.h"
 #include "robomongo/core/utils/QtUtils.h"
+#include "robomongo/core/mongodb/SshTunnelWorker.h"
 
 namespace Robomongo
 {
-    const QSize ConnectionDiagnosticDialog::dialogSize = QSize(300,200);
-
     ConnectionDiagnosticDialog::ConnectionDiagnosticDialog(ConnectionSettings *connection, QWidget *parent) :
-        BaseClass(parent),
-        _connection(connection),
-        _connectionStatusReceived(false),
-        _authStatusReceived(false)
+        QDialog(parent),
+        _connection(NULL),
+        _server(NULL),
+        _serverHandle(0),
+        _continueExec(true)
     {
+        _connection = connection->clone();
+
+        AppRegistry::instance().bus()->subscribe(this, ConnectionEstablishedEvent::Type);
+        AppRegistry::instance().bus()->subscribe(this, ConnectionFailedEvent::Type);
+
         setWindowTitle("Diagnostic");
         setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint); // Remove help button (?)
-        //setFixedSize(dialogSize);
 
         _yesIcon = GuiRegistry::instance().yesMarkIcon();
         _noIcon = GuiRegistry::instance().noMarkIcon();
-        _yesPixmap = _yesIcon.pixmap(24, 24);
-        _noPixmap = _noIcon.pixmap(24, 24);
+        _questionIcon = GuiRegistry::instance().questionMarkIcon();
+        _yesPixmap = _yesIcon.pixmap(20, 20);
+        _noPixmap = _noIcon.pixmap(20, 20);
+        _questionPixmap = _questionIcon.pixmap(20, 20);
 
         QPushButton *closeButton = new QPushButton("&Close");
         VERIFY(connect(closeButton, SIGNAL(clicked()), this, SLOT(accept())));
         _connectionIconLabel = new QLabel;
-        _authIconLabel = new QLabel;
         _connectionLabel = new QLabel;
+        _authIconLabel = new QLabel;
         _authLabel = new QLabel;
+        _sshIconLabel = new QLabel;
+        _sshLabel = new QLabel;
+        _listIconLabel = new QLabel;
+        _listLabel = new QLabel;
 
-        _loadingMovie = new QMovie(":robomongo/icons/loading.gif", QByteArray(), this);
+        _viewErrorLink = new QLabel("<a href='error' style='color: #777777;'>Show error details</a>");
+        VERIFY(connect(_viewErrorLink, SIGNAL(linkActivated(QString)), this, SLOT(errorLinkActivated(QString))));
+
+        _loadingMovie = new QMovie(":robomongo/icons/loading_ticks_40x40.gif", QByteArray(), this);
+        _loadingMovie->setScaledSize(QSize(20, 20));
         _loadingMovie->start();
 
         _connectionIconLabel->setMovie(_loadingMovie);
+        _sshIconLabel->setMovie(_loadingMovie);
         _authIconLabel->setMovie(_loadingMovie);
-
-        _connectionLabel->setText(QString("Connecting to <b>%1</b>...").arg(QtUtils::toQString(_connection->getFullAddress())));
-
-        if (_connection->hasEnabledPrimaryCredential()) {
-            _authLabel->setText(QString("Authorizing on <b>%1</b> database as <b>%2</b>...")
-                .arg(QtUtils::toQString(_connection->primaryCredential()->databaseName()))
-                .arg(QtUtils::toQString(_connection->primaryCredential()->userName())));
-        } else {
-            _authLabel->setText("Authorization skipped by you");
-        }
+        _listIconLabel->setMovie(_loadingMovie);
 
         QGridLayout *layout = new QGridLayout();
         layout->setContentsMargins(20, 20, 20, 10);
-        layout->addWidget(_connectionIconLabel, 0, 0);
-        layout->addWidget(_connectionLabel,     0, 1, Qt::AlignLeft);
-        layout->addWidget(_authIconLabel,       1, 0);
-        layout->addWidget(_authLabel,           1, 1, Qt::AlignLeft);
-        layout->setSizeConstraint(QLayout::SetFixedSize);
+        layout->addWidget(_sshIconLabel,        0, 0);
+        layout->addWidget(_sshLabel,            0, 1, Qt::AlignLeft);
+        layout->addWidget(_connectionIconLabel, 1, 0);
+        layout->addWidget(_connectionLabel,     1, 1, Qt::AlignLeft);
+        layout->addWidget(_authIconLabel,       2, 0);
+        layout->addWidget(_authLabel,           2, 1, Qt::AlignLeft);
+        layout->addWidget(_listIconLabel,       3, 0);
+        layout->addWidget(_listLabel,           3, 1, Qt::AlignLeft);
+        layout->setColumnStretch(0, 0) ; // Give column 0 no stretch ability
+        layout->setColumnStretch(1, 1) ; // Give column 1 stretch ability of ratio 1
+
+        QHBoxLayout *hbox = new QHBoxLayout;
+        hbox->addSpacing(21);
+        hbox->addWidget(_viewErrorLink, 1, Qt::AlignLeft);
+        hbox->addWidget(closeButton, 0, Qt::AlignRight);
 
         QVBoxLayout *box = new QVBoxLayout;
         box->addLayout(layout);
         box->addSpacing(10);
-        box->addWidget(closeButton, 0, Qt::AlignRight);
+        box->addLayout(hbox);
         setLayout(box);
 
-        ConnectionDiagnosticThread *thread = new ConnectionDiagnosticThread(_connection);
-        VERIFY(connect(thread, SIGNAL(connectionStatus(QString, bool)), this, SLOT(connectionStatus(QString, bool))));
-        VERIFY(connect(thread, SIGNAL(authStatus(QString, bool)), this, SLOT(authStatus(QString, bool))));
-        VERIFY(connect(thread, SIGNAL(completed()), this, SLOT(completed())));
-        VERIFY(connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())));
-        thread->start();
-    }
+        sshStatus(InitialState);
+        connectionStatus(InitialState);
+        authStatus(InitialState);
+        listStatus(InitialState);
 
-    void ConnectionDiagnosticDialog::connectionStatus(QString error, bool connected)
-    {
-        _connectionStatusReceived = true;
+        _viewErrorLink->hide();
 
-        if (connected) {
-            _connectionIconLabel->setPixmap(_yesPixmap);
-            _connectionLabel->setText(QString("Connected to <b>%1</b>").arg(QtUtils::toQString(_connection->getFullAddress())));
-        } else {
-            _connectionIconLabel->setPixmap(_noPixmap);
-            _connectionLabel->setText(QString("Unable to connect to <b>%1</b>").arg(QtUtils::toQString(_connection->getFullAddress())));
-        }
-
-        layout()->activate();
-        setFixedSize(minimumSizeHint());
-    }
-
-    void ConnectionDiagnosticDialog::authStatus(QString error, bool authed)
-    {
-        _authStatusReceived = true;
-
-        if (authed) {
-            _authIconLabel->setPixmap(_yesPixmap);
-            _authLabel->setText(QString("Authorized as <b>%1</b>").arg(QtUtils::toQString(_connection->primaryCredential()->userName())));
-        } else {
-
-            _authIconLabel->setPixmap(_noPixmap);
-
-            if (_connection->hasEnabledPrimaryCredential())
-                _authLabel->setText(QString("Authorization failed"));
-            else
-                _authLabel->setText(QString("Authorization skipped by you"));
-        }
-
-        layout()->activate();
-        setFixedSize(minimumSizeHint());
-    }
-
-    void ConnectionDiagnosticDialog::completed()
-    {
-        if (!_connectionStatusReceived)
-            connectionStatus("", false);
-
-        if (!_authStatusReceived)
-            authStatus("", false);
-
-        // seems that it is wrong to call any method on thread,
-        // because thread already can be disposed.
-        // QThread *thread = static_cast<QThread *>(sender());
-        // thread->quit();
-    }
-
-
-    ConnectionDiagnosticThread::ConnectionDiagnosticThread(ConnectionSettings *connection) :
-        _connection(connection) { }
-
-    void ConnectionDiagnosticThread::run()
-    {
-        boost::scoped_ptr<mongo::DBClientConnection> connection;
-
-        try {
-            connection.reset(new mongo::DBClientConnection);
-            connection->connect(_connection->info());
-            emit connectionStatus("", true);
-        }
-        catch(const mongo::UserException &ex) {
-            const char *what = ex.what();
-            emit connectionStatus(QString(what), false);
-            emit completed();
+        if (!AppRegistry::instance().app()->openServer(_connection, ConnectionTest)) {
+            _continueExec = false;
             return;
         }
 
-        try {
-            if (_connection->hasEnabledPrimaryCredential())
-            {
-                CredentialSettings *credentials = _connection->primaryCredential();
+        _serverHandle = AppRegistry::instance().app()->getLastServerHandle();
+    }
 
-                // Building BSON object:
-                mongo::BSONObj authParams(mongo::BSONObjBuilder()
-                    .append("user", credentials->userName())
-                    .append("db", credentials->databaseName())
-                    .append("pwd", credentials->userPassword())
-                    .append("mechanism", credentials->mechanism())
-                    .obj());
+    ConnectionDiagnosticDialog::~ConnectionDiagnosticDialog() {
+        if (_server)
+            AppRegistry::instance().app()->closeServer(_server);
+    }
 
-                connection->auth(authParams);
-                emit authStatus("", true);
-            }
-        } catch (const mongo::UserException &ex) {
-            emit authStatus("", false);
+    void ConnectionDiagnosticDialog::errorLinkActivated(const QString &link) {
+        if (_lastErrorMessage.empty())
+            return;
+
+        QMessageBox::information(this, "Error details", QtUtils::toQString(_lastErrorMessage));
+    }
+
+    void ConnectionDiagnosticDialog::sshStatus(State state)
+    {
+        if (!_connection->sshSettings()->enabled()) {
+            _sshIconLabel->setVisible(false);
+            _sshLabel->setVisible(false);
+            return;
         }
 
-        emit completed();
+        if (state == InitialState) {
+            _sshIconLabel->setMovie(_loadingMovie);
+            _sshLabel->setText(QString("Connecting to SSH server at <b>%1:%2</b>...")
+                .arg(QtUtils::toQString(_connection->sshSettings()->host()))
+                .arg(_connection->sshSettings()->port()));
+        } else if (state == CompletedState) {
+            _sshIconLabel->setPixmap(_yesPixmap);
+            _sshLabel->setText(QString("Connected to SSH server at <b>%1:%2</b>")
+                .arg(QtUtils::toQString(_connection->sshSettings()->host()))
+                .arg(_connection->sshSettings()->port()));
+        } else if (state == FailedState) {
+            _sshIconLabel->setPixmap(_noPixmap);
+            _sshLabel->setText(QString("Unable to connect to SSH server at <b>%1:%2</b>")
+                .arg(QtUtils::toQString(_connection->sshSettings()->host()))
+                .arg(_connection->sshSettings()->port()));
+        }
+    }
+
+    void ConnectionDiagnosticDialog::connectionStatus(State state)
+    {
+        // Add info about tunneling if SSH or SSL is used
+        QString tunnelNote("");    // No tunnel info when neither SSH nor SSL enabled
+        if (_connection->sshSettings()->enabled()) 
+        {
+            tunnelNote = " via SSH tunnel";
+        }
+        else if (_connection->sslSettings()->sslEnabled()) 
+        {
+            tunnelNote = " via SSL tunnel";
+        }
+
+        // Set main info text at dialog
+        if (state == InitialState) {
+            _connectionIconLabel->setMovie(_loadingMovie);
+            _connectionLabel->setText(QString("Connecting to <b>%1</b>%2...").arg(QtUtils::toQString(_connection->getFullAddress()), tunnelNote));
+        } else if (state == CompletedState) {
+            _connectionIconLabel->setPixmap(_yesPixmap);
+            _connectionLabel->setText(QString("Connected to <b>%1</b>%2").arg(QtUtils::toQString(_connection->getFullAddress()), tunnelNote));
+        } else if (state == FailedState) {
+            _connectionIconLabel->setPixmap(_noPixmap);
+            _connectionLabel->setText(QString("Failed to connect to <b>%1</b>%2").arg(QtUtils::toQString(_connection->getFullAddress()), tunnelNote));
+        } else if (state == NotPerformedState) {
+            _connectionIconLabel->setPixmap(_questionPixmap);
+            _connectionLabel->setText(QString("No chance to try connection to <b>%1</b>%2").arg(QtUtils::toQString(_connection->getFullAddress()), tunnelNote));
+        }
+    }
+
+    void ConnectionDiagnosticDialog::authStatus(State state)
+    {
+        if (!_connection->hasEnabledPrimaryCredential()) {
+            _authIconLabel->setVisible(false);
+            _authLabel->setVisible(false);
+            return;
+        }
+
+        if (state == InitialState) {
+            _authIconLabel->setMovie(_loadingMovie);
+            _authLabel->setText(QString("Authorizing on <b>%1</b> database as <b>%2</b>...")
+                .arg(QtUtils::toQString(_connection->primaryCredential()->databaseName()))
+                .arg(QtUtils::toQString(_connection->primaryCredential()->userName())));
+        } else if (state == CompletedState) {
+            _authIconLabel->setPixmap(_yesPixmap);
+            _authLabel->setText(QString("Authorized on <b>%1</b> database as <b>%2</b>")
+                .arg(QtUtils::toQString(_connection->primaryCredential()->databaseName()))
+                .arg(QtUtils::toQString(_connection->primaryCredential()->userName())));
+        } else if (state == FailedState) {
+            _authIconLabel->setPixmap(_noPixmap);
+            _authLabel->setText(QString("Authorization failed on <b>%1</b> database as <b>%2</b>")
+                .arg(QtUtils::toQString(_connection->primaryCredential()->databaseName()))
+                .arg(QtUtils::toQString(_connection->primaryCredential()->userName())));
+        } else if (state == NotPerformedState) {
+            _authIconLabel->setPixmap(_questionPixmap);
+            _authLabel->setText(QString("No chance to authorize"));
+        }
+    }
+
+    void ConnectionDiagnosticDialog::listStatus(State state)
+    {
+        if (_connection->hasEnabledPrimaryCredential()) {
+            _listIconLabel->setVisible(false);
+            _listLabel->setVisible(false);
+            return;
+        }
+
+        if (state == InitialState) {
+            _listIconLabel->setMovie(_loadingMovie);
+            _listLabel->setText(QString("Loading list of databases..."));
+        } else if (state == CompletedState) {
+            _listIconLabel->setPixmap(_yesPixmap);
+            _listLabel->setText(QString("Access to databases is available"));
+        } else if (state == FailedState) {
+            _listIconLabel->setPixmap(_noPixmap);
+            _listLabel->setText(QString("Failed to load list of databases"));
+        } else if (state == NotPerformedState) {
+            _listIconLabel->setPixmap(_questionPixmap);
+            _listLabel->setText(QString("No chance to load list of databases"));
+        }
+    }
+
+    void ConnectionDiagnosticDialog::handle(ConnectionEstablishedEvent *event) {
+        if (event->connectionType != ConnectionTest)
+            return;
+
+        sshStatus(CompletedState);
+        connectionStatus(CompletedState);
+        authStatus(CompletedState);
+        listStatus(CompletedState);
+
+        // Remember in order to delete on dialog close
+        _server = static_cast<MongoServer*>(event->sender());
+    }
+
+    void ConnectionDiagnosticDialog::handle(ConnectionFailedEvent *event) {
+        if (event->connectionType != ConnectionTest || event->serverHandle != _serverHandle)
+            return;
+
+        sshStatus(CompletedState);
+        connectionStatus(CompletedState);
+        authStatus(CompletedState);
+        listStatus(CompletedState);
+
+        switch (event->reason) {
+        case ConnectionFailedEvent::SshConnection:
+            sshStatus(FailedState);
+            connectionStatus(NotPerformedState);
+            authStatus(NotPerformedState);
+            listStatus(NotPerformedState);
+            break;
+        case ConnectionFailedEvent::SshChannel:
+        case ConnectionFailedEvent::MongoConnection:
+            connectionStatus(FailedState);
+            authStatus(NotPerformedState);
+            listStatus(NotPerformedState);
+            break;
+        case ConnectionFailedEvent::MongoAuth:
+            authStatus(FailedState);
+            listStatus(FailedState);
+            break;
+        case ConnectionFailedEvent::SslConnection:
+            connectionStatus(FailedState);
+            authStatus(NotPerformedState);
+            listStatus(NotPerformedState);
+            break;
+        }
+
+        // Show link for additional error details
+        if (!event->message.empty()) {
+            _lastErrorMessage = event->message;
+            _viewErrorLink->show();
+        }
     }
 }

src/robomongo/gui/dialogs/ConnectionDiagnosticDialog.h

@@ -2,63 +2,69 @@
 
 #include <QDialog>
 #include <QIcon>
-#include <QThread>
-QT_BEGIN_NAMESPACE
+
 class QLabel;
 class QMovie;
-QT_END_NAMESPACE
 
 namespace Robomongo
 {
+    class ConnectionEstablishedEvent;
+    class ConnectionFailedEvent;
     class ConnectionSettings;
+    class MongoServer;
 
     class ConnectionDiagnosticDialog : public QDialog
     {
         Q_OBJECT
     public:
-        typedef QDialog BaseClass;
-        static const QSize dialogSize;        
         ConnectionDiagnosticDialog(ConnectionSettings *connection, QWidget *parent = 0);
+        ~ConnectionDiagnosticDialog();
+
+        bool continueExec() const { return _continueExec; }
 
     protected Q_SLOTS:
-        void connectionStatus(QString error, bool connected);
-        void authStatus(QString error, bool authed);
-        void completed();
+        void handle(ConnectionEstablishedEvent *event);
+        void handle(ConnectionFailedEvent *event);
+        void errorLinkActivated(const QString &link);
 
     private:
+
+        enum State {
+            InitialState,
+            CompletedState,
+            FailedState,
+            NotPerformedState
+        };
+
+        void sshStatus(State state);
+        void connectionStatus(State state);
+        void authStatus(State state);
+        void listStatus(State state);
+
         ConnectionSettings *_connection;
         QIcon _yesIcon;
         QIcon _noIcon;
-        QIcon _waitIcon;
+        QIcon _questionIcon;
         QMovie *_loadingMovie;
 
         QPixmap _yesPixmap;
         QPixmap _noPixmap;
+        QPixmap _questionPixmap;
 
+        QLabel *_sshIconLabel;
+        QLabel *_sshLabel;
         QLabel *_connectionIconLabel;
         QLabel *_connectionLabel;
         QLabel *_authIconLabel;
         QLabel *_authLabel;
+        QLabel *_listIconLabel;  // List database names
+        QLabel *_listLabel;
 
-        bool _connectionStatusReceived;
-        bool _authStatusReceived;
-    };
+        QLabel *_viewErrorLink;
+        std::string _lastErrorMessage;
 
-    class ConnectionDiagnosticThread : public QThread
-    {
-        Q_OBJECT
-    public:
-        ConnectionDiagnosticThread(ConnectionSettings *connection);
-
-    Q_SIGNALS:
-        void connectionStatus(QString error, bool connected);
-        void authStatus(QString error, bool authed);
-        void completed();
-
-    protected:
-        void run();
-
-    private:
-        ConnectionSettings *_connection;
+        MongoServer *_server;
+        int _serverHandle;
+        bool _continueExec;
     };
 }

src/robomongo/gui/dialogs/ConnectionDialog.cpp

@@ -15,6 +15,7 @@
 #include "robomongo/gui/dialogs/ConnectionSslTab.h"
 #include "robomongo/gui/dialogs/ConnectionSslTab.h"
 #include "robomongo/gui/dialogs/SSHTunnelTab.h"
+#include "robomongo/gui/dialogs/SSLTab.h"
 #include "robomongo/gui/dialogs/ConnectionDiagnosticDialog.h"
 #include "robomongo/core/utils/QtUtils.h"
 
@@ -50,18 +51,14 @@ namespace Robomongo
         _basicTab    = new ConnectionBasicTab(_connection);
         _authTab     = new ConnectionAuthTab(_connection);
         _advancedTab = new ConnectionAdvancedTab(_connection);
-        _sshTab = new SshTunnelTab(_connection);
-
-        // v0.9
-        //_sslTab      = new ConnectionSslTab(_connection);
+        _sshTab      = new SshTunnelTab(_connection);
+        _sslTab      = new SSLTab(_connection);
 
         tabWidget->addTab(_basicTab,    "Connection");
         tabWidget->addTab(_authTab,     "Authentication");
-        tabWidget->addTab(_advancedTab, "Advanced");
         tabWidget->addTab(_sshTab,      "SSH");
-
-        // v0.9
-        //tabWidget->addTab(_sslTab,      "SSL");
+        tabWidget->addTab(_sslTab,      "SSL");
+        tabWidget->addTab(_advancedTab, "Advanced");
 
         QVBoxLayout *mainLayout = new QVBoxLayout;
         mainLayout->addWidget(tabWidget);
@@ -69,6 +66,10 @@ namespace Robomongo
         setLayout(mainLayout);
 
         _basicTab->setFocus();
+        adjustSize();
+
+        // Set minimum width - adjustment after adding SSLTab
+        setMinimumWidth(550);
     }
 
     /**
@@ -76,27 +77,29 @@ namespace Robomongo
      */
     void ConnectionDialog::accept()
     {
-        if (validateAndApply()){
+        if (validateAndApply()) {
             QDialog::accept();
         }
     }
 
     bool ConnectionDialog::validateAndApply()
     {
-#ifdef SSH_SUPPORT_ENABLED
-        bool isSshAndSsl = _sslTab->isSslSupported() && _sshTab->isSshSupported();
-        if (isSshAndSsl) {
-            QMessageBox::warning(this, "Invalid Transport", "SSH and SSL cannot be enabled simultaneously. Please uncheck one of them.");
+        bool sshAndSslChecked = (_sslTab->sslEnabled() && _sshTab->sshEnabled());
+        if (sshAndSslChecked) 
+        {
+            QMessageBox::warning(this, "Invalid Configuration", "SSH and SSL cannot be enabled simultaneously. "
+                "Please use one of them.");
             return false;
         }
-#endif
         _basicTab->accept();
         _authTab->accept();
         _advancedTab->accept();
-        _sshTab->accept();
 
-        // v0.9
-        // _sslTab->accept();
+        if (!_sshTab->accept() || !_sslTab->accept())
+        {
+            return false;
+        }
+
         return true;
     }
 
@@ -105,9 +108,13 @@ namespace Robomongo
      */
     void ConnectionDialog::testConnection()
     {
-        if(validateAndApply()){
-            ConnectionDiagnosticDialog diag(_connection,this);
-            diag.exec();
-        }
+        if (!validateAndApply())
+            return;
+
+        ConnectionDiagnosticDialog diag(_connection, this);
+        if (!diag.continueExec())
+            return;
+
+        diag.exec();
     }
 }

src/robomongo/gui/dialogs/ConnectionDialog.h

@@ -10,7 +10,7 @@ namespace Robomongo
     class ConnectionAuthTab;
     class ConnectionBasicTab;
     class ConnectionAdvancedTab;
-    class ConnectionSslTab;
+    class SSLTab;
     class SshTunnelTab;
     /**
      * @brief This Dialog allows to edit single connection
@@ -44,9 +44,7 @@ namespace Robomongo
         ConnectionBasicTab *_basicTab;
         ConnectionAdvancedTab *_advancedTab;
         SshTunnelTab *_sshTab;
-
-        // v0.9
-        //ConnectionSslTab *_sslTab;
+        SSLTab *_sslTab;
 
 #ifdef SSH_SUPPORT_ENABLED
         SshTunnelTab *_sshTab;

src/robomongo/gui/dialogs/ConnectionSslTab.cpp

@@ -36,7 +36,7 @@ namespace Robomongo
         _sslSupport->setChecked(_settings->sslInfo()._sslSupport);
 
         _selectPemFileButton = new QPushButton("...");
-        _selectPemFileButton->setFixedSize(20,20);
+        _selectPemFileButton->setFixedSize(20, 20);
         VERIFY(connect(_selectPemFileButton, SIGNAL(clicked()), this, SLOT(setSslPEMKeyFile())));
 
         _sslPemLabel = new QLabel("SSL Certificate:");

src/robomongo/gui/dialogs/ConnectionsDialog.cpp

@@ -9,8 +9,11 @@
 #include <QDialogButtonBox>
 #include <QTreeWidgetItem>
 #include <QKeyEvent>
+#include <QApplication>
+#include <QSettings>
 
 #include "robomongo/core/settings/ConnectionSettings.h"
+#include "robomongo/core/settings/ReplicaSetSettings.h"
 #include "robomongo/core/settings/CredentialSettings.h"
 #include "robomongo/core/settings/SettingsManager.h"
 #include "robomongo/core/utils/QtUtils.h"
@@ -42,8 +45,15 @@ namespace Robomongo
          */
         void setConnection(ConnectionSettings *connection)
         {
-            setText(0, QtUtils::toQString(connection->connectionName()));
-            setText(1, QtUtils::toQString(connection->getFullAddress()));
+            if (connection->isReplicaSet()) {
+                setText(0, QtUtils::toQString(connection->connectionName()) + " [Replica Set]");
+                auto const repSetSize = connection->replicaSetSettings()->members().size();
+                setText(1, QString::number(repSetSize) + " Servers (" + QtUtils::toQString(connection->getFullAddress()) + ")");
+            }
+            else {
+                setText(0, QtUtils::toQString(connection->connectionName()));
+                setText(1, QtUtils::toQString(connection->getFullAddress()));
+            }
 
             if (connection->hasEnabledPrimaryCredential()) {
                 QString authString = QString("%1 / %2").arg(QtUtils::toQString(connection->primaryCredential()->databaseName())).arg(QtUtils::toQString(connection->primaryCredential()->userName()));
@@ -55,7 +65,16 @@ namespace Robomongo
             }
 
             _connection = connection;
-            setIcon(0, GuiRegistry::instance().serverIcon());
+            if (connection->isReplicaSet()) { 
+                setIcon(0, GuiRegistry::instance().replicaSetIcon());
+            }
+            else {
+                setIcon(0, GuiRegistry::instance().serverIcon());
+            }
+
+            if (connection->imported()) {
+                setIcon(0, GuiRegistry::instance().serverImportedIcon());
+            }
         }
 
     private:
@@ -65,8 +84,8 @@ namespace Robomongo
     /**
      * @brief Creates dialog
      */
-    ConnectionsDialog::ConnectionsDialog(SettingsManager *settingsManager, QWidget *parent) 
-        : QDialog(parent), _settingsManager(settingsManager)
+    ConnectionsDialog::ConnectionsDialog(SettingsManager *settingsManager, bool checkForImported, QWidget *parent)
+        : QDialog(parent), _settingsManager(settingsManager), _checkForImported(checkForImported)
     {
         setWindowIcon(GuiRegistry::instance().connectIcon());
         setWindowTitle("MongoDB Connections");
@@ -124,13 +143,33 @@ namespace Robomongo
         VERIFY(connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject())));
 
         QHBoxLayout *bottomLayout = new QHBoxLayout;
-        bottomLayout->addWidget(buttonBox);
 
-        QLabel *intro = new QLabel(
-            "<a href='create'>Create</a>, "
-            "<a href='edit'>edit</a>, "
-            "<a href='remove'>remove</a>, "
-            "<a href='clone'>clone</a> or reorder connections via drag'n'drop.");
+        // Information message is shown when connection
+        // settings are imported from previous version of Robomongo
+        int importedCount = _settingsManager->importedConnectionsCount();
+        if (_checkForImported && importedCount > 0) {
+            QIcon importIcon = qApp->style()->standardIcon(QStyle::SP_MessageBoxInformation);
+            QPixmap importPixmap = importIcon.pixmap(20, 20);
+            QLabel *importLabelIcon = new QLabel;
+            importLabelIcon->setPixmap(importPixmap);
+            QString importedRecords = importedCount > 1 ? "records" : "record";
+            QLabel *importLabelMessage = new QLabel(QString(
+                "<span style='color: #777777;'>"
+                "Connection settings have been imported (%1 %2)"
+                "</span>").arg(importedCount).arg(importedRecords));
+
+            bottomLayout->addWidget(importLabelIcon, 0, Qt::AlignLeft);
+            bottomLayout->addWidget(importLabelMessage, 1, Qt::AlignLeft);
+        }
+
+        bottomLayout->addWidget(buttonBox, 0, Qt::AlignRight);
+
+        QLabel *intro = new QLabel(QString(
+            "<a style='color: %1' href='create'>Create</a>, "
+            "<a style='color: %1' href='edit'>edit</a>, "
+            "<a style='color: %1' href='remove'>remove</a>, "
+            "<a style='color: %1' href='clone'>clone</a> "
+            "or reorder connections via drag'n'drop.").arg("#106CD6"));
         intro->setWordWrap(true);
 
         VERIFY(connect(intro, SIGNAL(linkActivated(QString)), this, SLOT(linkActivated(QString))));
@@ -155,6 +194,8 @@ namespace Robomongo
             _listWidget->setCurrentItem(_listWidget->topLevelItem(0));
 
         _listWidget->setFocus();
+
+        restoreWindowsSettings();
     }
 
     /**
@@ -169,10 +210,23 @@ namespace Robomongo
             return;
 
         _selectedConnection = currentItem->connection();
+        saveWindowsSettings();
 
         QDialog::accept();
     }
 
+    void ConnectionsDialog::reject()
+    {
+        saveWindowsSettings();
+        QDialog::reject();
+    }
+
+    void ConnectionsDialog::closeEvent(QCloseEvent *event)
+    {
+        saveWindowsSettings();
+        QWidget::closeEvent(event);
+    }
+
     void ConnectionsDialog::linkActivated(const QString &link)
     {
         if (link == "create")
@@ -233,7 +287,7 @@ namespace Robomongo
         activateWindow();
 
         int size = _connectionItems.size();
-        for (int i=0; i<size; ++i)
+        for (int i = 0; i<size; ++i)
         {
             ConnectionListWidgetItem *item = _connectionItems[i];
             if (_connectionItems[i]->connection() == connection) {
@@ -281,7 +335,7 @@ namespace Robomongo
 
         // Clone connection
         ConnectionSettings *connection = currentItem->connection()->clone();
-        std::string newConnectionName="Copy of "+connection->connectionName();
+        std::string newConnectionName = "Copy of "+connection->connectionName();
 
         connection->setConnectionName(newConnectionName);
 
@@ -307,7 +361,7 @@ namespace Robomongo
 
         // Make childrens toplevel again. This is a bad, but quickiest item reordering
         // implementation.
-        for(int i = 0; i < count; i++)
+        for (int i = 0; i < count; i++)
         {
             ConnectionListWidgetItem * item = (ConnectionListWidgetItem *) _listWidget->topLevelItem(i);
             if (item->childCount() > 0) {
@@ -321,7 +375,7 @@ namespace Robomongo
 
         count = _listWidget->topLevelItemCount();
         SettingsManager::ConnectionSettingsContainerType items;
-        for(int i = 0; i < count; i++)
+        for (int i = 0; i < count; i++)
         {
             ConnectionListWidgetItem * item = (ConnectionListWidgetItem *) _listWidget->topLevelItem(i);
             items.push_back(item->connection());
@@ -362,6 +416,17 @@ namespace Robomongo
         QDialog::keyPressEvent(event);
     }
 
+    void ConnectionsDialog::restoreWindowsSettings()
+    {
+        QSettings settings("Paralect", "Robomongo");
+        resize(settings.value("ConnectionsDialog/size").toSize());
+    }
+
+    void ConnectionsDialog::saveWindowsSettings() const
+    {
+        QSettings settings("Paralect", "Robomongo");
+        settings.setValue("ConnectionsDialog/size", size());
+    }
 
     ConnectionsTreeWidget::ConnectionsTreeWidget()
     {

src/robomongo/gui/dialogs/ConnectionsDialog.h

@@ -23,7 +23,7 @@ namespace Robomongo
         /**
          * @brief Creates dialog
          */
-        ConnectionsDialog(SettingsManager *manager, QWidget *parent = 0);
+        ConnectionsDialog(SettingsManager *manager, bool checkForImported, QWidget *parent = 0);
 
         /**
          * @brief ConnectionSettings, that was selected after pressing on
@@ -31,11 +31,23 @@ namespace Robomongo
          */
         ConnectionSettings *selectedConnection() const { return _selectedConnection; }
 
+    public Q_SLOTS:
         /**
          * @brief This function is called when user clicks on "Connect" button.
          */
         virtual void accept();
 
+        /**
+        * @brief Called when "Cancel" button clicked.
+        */
+        virtual void reject();
+
+    protected:
+        /**
+        * @brief Reimplementing closeEvent in order to do some pre-close actions.
+        */
+        void closeEvent(QCloseEvent *event);
+
     private Q_SLOTS:
         void linkActivated(const QString &link);
 
@@ -75,6 +87,17 @@ namespace Robomongo
         void keyPressEvent(QKeyEvent* event);
 
     private:
+
+        /**
+        * @brief Restore windows settings from system registry
+        */
+        void restoreWindowsSettings();
+
+        /**
+        * @brief Save windows settings into system registry
+        */
+        void saveWindowsSettings() const;
+
         /**
          * @brief ConnectionSettings, that was selected after pressing on
          * "Connect" button
@@ -96,6 +119,8 @@ namespace Robomongo
          * ConnectionListWidgetItem*
          */
         ConnectionListItemContainerType _connectionItems;
+
+        bool _checkForImported;
     };    
 
     class ConnectionsTreeWidget : public QTreeWidget

src/robomongo/gui/dialogs/CopyCollectionDialog.cpp

@@ -18,7 +18,7 @@
 
 namespace Robomongo
 {
-    const QSize CopyCollection::minimumSize = QSize(300,150);
+    const QSize CopyCollection::minimumSize = QSize(300, 150);
 
     CopyCollection::CopyCollection(const QString &serverName, const QString &database,
                                                const QString &collection, QWidget *parent) :
@@ -28,9 +28,9 @@ namespace Robomongo
     {
         App::MongoServersContainerType servers = AppRegistry::instance().app()->getServers();
         QSet<QString> uniqueConnectionsNames;
-        for(App::MongoServersContainerType::const_iterator it = servers.begin(); it != servers.end(); ++it){
+        for (App::MongoServersContainerType::const_iterator it = servers.begin(); it != servers.end(); ++it) {
              MongoServer *server = *it;
-             if (server->isConnected() ){
+             if (server->isConnected()) {
                  _servers.push_back(server);
                  uniqueConnectionsNames.insert(QtUtils::toQString(server->connectionRecord()->connectionName()));
              }
@@ -109,7 +109,7 @@ namespace Robomongo
             }
         }  
         _databaseComboBox->addItems(server->getDatabasesNames());
-        if (_currentServerName==QtUtils::toQString(server->connectionRecord()->getFullAddress())) {
+        if (_currentServerName == QtUtils::toQString(server->connectionRecord()->getFullAddress())) {
             _databaseComboBox->removeItem(_databaseComboBox->findText(_currentDatabase));
         }
     }

src/robomongo/gui/dialogs/CreateCollectionDialog.cpp

@@ -0,0 +1,581 @@
+#include "robomongo/gui/dialogs/CreateCollectionDialog.h"
+
+#include <mongo/bson/bsonobjbuilder.h>
+#include <QApplication>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDialogButtonBox>
+#include <QHBoxLayout>
+#include <QLineEdit>
+#include <QLabel>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QSettings>
+#include <Qsci/qscilexerjavascript.h>
+#include <Qsci/qsciscintilla.h>
+#include <QVBoxLayout>
+
+#include "robomongo/gui/widgets/workarea/IndicatorLabel.h"
+#include "robomongo/gui/GuiRegistry.h"
+#include "robomongo/core/domain/MongoDatabase.h"
+#include "robomongo/core/utils/QtUtils.h"
+#include "robomongo/gui/editors/FindFrame.h"
+#include "robomongo/gui/editors/JSLexer.h"
+#include "robomongo/gui/editors/PlainJavaScriptEditor.h"
+#include "robomongo/shell/bson/json.h"
+
+namespace Robomongo
+{
+    enum
+    {
+        OPTIONS_TAB                 = 0,
+        STORAGE_ENGINE_TAB          = 1,
+        VALIDATOR_TAB               = 2,
+        INDEX_OPTION_DEFAULTS_TAB   = 3,
+    };
+
+    const QString CreateCollectionDialog::STORAGE_ENGINE_TAB_HINT = "Option available for WiredTiger storage engine only and database version 3.0 and higher.";
+    const QString CreateCollectionDialog::VALIDATOR_TAB_HINT = "Option available for database version 3.2 and higher.";
+    const QString CreateCollectionDialog::INDEX_OPTION_DEFAULTS_TAB_HINT = "Option available for database version 3.2 and higher.";
+    const QString CreateCollectionDialog::NO_PADDING_HINT = "Option available for MMAPv1 storage engine only and database version 3.0 and higher.";
+    const QString CreateCollectionDialog::USE_POWEROFTWO_HINT = "Option available for MMAPv1 storage engine only and deprecated since database version 3.0";
+    const QString CreateCollectionDialog::AUTO_INDEXID_HINT = "Option deprecated since database version 3.2";
+
+    CreateCollectionDialog::CreateCollectionDialog(const QString &serverName, const float dbVersion, const std::string& storageEngine, 
+        const QString &database, const QString &collection, QWidget *parent) :
+        QDialog(parent), _dbVersion(dbVersion), _storageEngine(storageEngine), 
+        _activeFrame(nullptr), _activeObj(&_storageEngineObj)
+    {
+        setWindowTitle(tr("Create Collection"));
+        setMinimumSize(300,150);
+        Indicator *serverIndicator = new Indicator(GuiRegistry::instance().serverIcon(), serverName);
+
+        QFrame *hline = new QFrame();
+        hline->setFrameShape(QFrame::HLine);
+        hline->setFrameShadow(QFrame::Sunken);
+
+        _inputEdit = new QLineEdit();
+        _inputLabel = new QLabel(tr("Collection Name:"));
+        _inputEdit->setMaxLength(60);
+
+        _buttonBox = new QDialogButtonBox(this);
+        _buttonBox->setOrientation(Qt::Horizontal);
+        _buttonBox->setStandardButtons(QDialogButtonBox::Cancel | QDialogButtonBox::Save);
+        _buttonBox->button(QDialogButtonBox::Save)->setText(tr("C&reate"));
+        _buttonBox->button(QDialogButtonBox::Save)->setEnabled(false);
+        VERIFY(connect(_buttonBox, SIGNAL(accepted()), this, SLOT(accept())));
+        VERIFY(connect(_buttonBox, SIGNAL(rejected()), this, SLOT(reject())));
+        VERIFY(connect(_inputEdit, SIGNAL(textChanged(const QString &)),
+            this, SLOT(enableCreateButton(const QString &))));
+
+        _validateJsonButton = new QPushButton(tr("Validate JSON"));
+        _validateJsonButton->setIcon(qApp->style()->standardIcon(QStyle::SP_MessageBoxInformation));
+        _validateJsonButton->hide();
+        VERIFY(connect(_validateJsonButton, SIGNAL(clicked()), this, SLOT(onValidateButtonClicked())));
+
+        // Create advanced options tabs
+        _advancedOptions = new QTabWidget(this);
+        _advancedOptions->addTab(createOptionsTab(), tr("Options"));
+        _advancedOptions->addTab(createStorageEngineTab(), tr("Storage Engine"));
+        _advancedOptions->addTab(createValidatorTab(), tr("Validator"));
+        _advancedOptions->addTab(createIndexOptionDefaultsTab(), tr("Index Option Defaults"));
+        _advancedOptions->setTabsClosable(false);
+        VERIFY(connect(_advancedOptions, SIGNAL(currentChanged(int)), this, SLOT(onTabChanged(int))));
+        // Create Advanced Button
+        _advancedButton = new QPushButton(tr("Advanced"));
+        _advancedButton->setCheckable(true);
+        VERIFY(connect(_advancedButton, SIGNAL(toggled(bool)), this, SLOT(onAdvancedButtonToggled(bool))));
+
+        // Check mongodb version and storage engine type to enable/disable UI options
+        disableUnsupportedOptions();
+
+        QHBoxLayout *buttomHlayout = new QHBoxLayout();
+        buttomHlayout->addWidget(_validateJsonButton);
+        buttomHlayout->addStretch(1);
+        buttomHlayout->addWidget(_buttonBox);
+        buttomHlayout->addWidget(_advancedButton);
+
+        QHBoxLayout *vlayout = new QHBoxLayout();
+        if (!serverName.isEmpty())
+            vlayout->addWidget(serverIndicator, 0, Qt::AlignLeft);
+        if (!database.isEmpty())
+            vlayout->addWidget(createDatabaseIndicator(database), 0, Qt::AlignLeft);
+        if (!collection.isEmpty())
+            vlayout->addWidget(createCollectionIndicator(collection), 0, Qt::AlignLeft);
+        vlayout->addStretch(1);
+
+        QVBoxLayout *namelayout = new QVBoxLayout();
+        namelayout->setContentsMargins(0, 7, 0, 7);
+        namelayout->addWidget(_inputLabel);
+        namelayout->addWidget(_inputEdit);
+        
+        QVBoxLayout *mainLayout = new QVBoxLayout();
+        mainLayout->addLayout(vlayout);
+        mainLayout->addWidget(hline);
+        mainLayout->addLayout(namelayout);
+        mainLayout->addWidget(_advancedOptions);
+        mainLayout->addLayout(buttomHlayout);
+        mainLayout->setSizeConstraint(QLayout::SetMaximumSize);
+        setLayout(mainLayout);
+
+        _advancedOptions->hide();
+        _inputEdit->setFocus();
+    }
+
+    const mongo::BSONObj CreateCollectionDialog::getExtraOptions() const
+    {
+        return _extraOptionsObj;
+    }
+
+    QString CreateCollectionDialog::getCollectionName() const
+    {
+        return _inputEdit->text();
+    }
+
+    bool CreateCollectionDialog::isCapped() const
+    {
+        return (_cappedCheckBox->checkState() == Qt::Checked);
+    }
+
+    long long CreateCollectionDialog::getSizeInputValue() const
+    {
+        return (_sizeInputEdit->text().toLongLong());
+    }
+
+    int CreateCollectionDialog::getMaxDocNumberInputValue() const
+    {
+        return (_maxDocNumberInputEdit->text().toInt());
+    }
+
+    bool CreateCollectionDialog::isCheckedAutoIndexid() const
+    {
+        return (_autoIndexCheckBox->checkState() == Qt::Checked);
+    }
+
+    bool CreateCollectionDialog::isCheckedUsePowerOfTwo() const
+    {
+        return (_usePowerOfTwoSizeCheckBox->checkState() == Qt::Checked);
+    }
+
+    bool CreateCollectionDialog::isCheckedNoPadding() const
+    {
+        return (_noPaddingCheckBox->checkState() == Qt::Checked);
+    }
+
+    void CreateCollectionDialog::accept()
+    {
+        if ( _inputEdit->text().isEmpty() 
+            || !validateOptionDependencies()
+            || !validate(_storageEngineFrame, _storageEngineObj)
+            || !validate(_validatorFrame, _validatorObj) 
+            || !validate(_indexOptionDefaultsFrame, _indexOptionDefaultsObj))
+        {
+            return;
+        }
+        
+        makeExtraOptionsObj();
+        saveWindowSettings();
+
+        QDialog::accept();
+    }
+
+    void CreateCollectionDialog::reject()
+    {
+        saveWindowSettings();
+        QDialog::reject();
+    }
+
+    void CreateCollectionDialog::closeEvent(QCloseEvent *event)
+    {
+        if (_advancedOptions->isVisible())
+        {
+            saveWindowSettings();
+        }
+        QWidget::closeEvent(event);
+    }
+
+    void CreateCollectionDialog::onFrameTextChanged()
+    {
+        _activeFrame->sciScintilla()->clearIndicatorRange(0, 0, _activeFrame->sciScintilla()->lines(), 40, 0);
+    }
+
+    void CreateCollectionDialog::onValidateButtonClicked()
+    {
+        validate(_activeFrame, *_activeObj, false);
+    }
+
+    void CreateCollectionDialog::enableCreateButton(const QString &text)
+    {
+        _buttonBox->button(QDialogButtonBox::Save)->setEnabled(!text.isEmpty());
+    }
+
+    void CreateCollectionDialog::onCappedCheckBoxChanged(int newState)
+    {
+        _sizeInputEdit->setEnabled((Qt::Checked == static_cast<Qt::CheckState>(newState)));
+        _maxDocNumberInputEdit->setEnabled((Qt::Checked == static_cast<Qt::CheckState>(newState)));
+    }
+
+    void CreateCollectionDialog::onTabChanged(int index)
+    {
+        if (OPTIONS_TAB == index) {    
+            _validateJsonButton->hide();
+        }
+        else {
+            _validateJsonButton->show();
+            if (STORAGE_ENGINE_TAB == index) {
+                _activeFrame = _storageEngineFrame;
+                _activeObj = &_storageEngineObj;
+            }
+            else if (VALIDATOR_TAB == index) {
+                _activeFrame = _validatorFrame;
+                _activeObj = &_validatorObj;
+            }
+            else if (INDEX_OPTION_DEFAULTS_TAB == index) {
+                _activeFrame = _indexOptionDefaultsFrame;
+                _activeObj = &_indexOptionDefaultsObj;
+            }
+        }
+    };
+
+    void CreateCollectionDialog::onAdvancedButtonToggled(bool state)
+    {
+        _advancedOptions->setVisible(state);
+        if (state)  // resize, dialog is expanding
+        {
+            setMinimumSize(560, 440);
+            _validateJsonButton->setHidden(_advancedOptions->currentIndex() == OPTIONS_TAB);
+            QSettings settings("Paralect", "Robomongo");
+            if (settings.contains("CreateCollectionDialog/size"))
+            {
+                restoreWindowSettings();
+            }
+            else
+            {
+                resize(560, 440);
+                adjustSize();
+            }
+        }
+        else        // resize, dialog is shrinking
+        {
+            saveWindowSettings();       // save expanded geometry first
+            _validateJsonButton->hide();
+            setFixedSize(300, 150);
+            adjustSize();
+        }
+    }
+
+    Indicator *CreateCollectionDialog::createDatabaseIndicator(const QString &database)
+    {
+        return new Indicator(GuiRegistry::instance().databaseIcon(), database);
+    }
+
+    Indicator *CreateCollectionDialog::createCollectionIndicator(const QString &collection)
+    {
+        return new Indicator(GuiRegistry::instance().collectionIcon(), collection);
+    }
+
+    QWidget* CreateCollectionDialog::createOptionsTab()
+    {
+        QWidget *optionsTab = new QWidget(this);
+
+        _cappedCheckBox = new QCheckBox(tr("Create capped collection"), optionsTab);
+        _sizeInputLabel = new QLabel(tr("Maximum size in bytes: "));
+        _sizeInputLabel->setContentsMargins(22, 0, 0, 0);
+        _sizeInputEdit = new QLineEdit();
+        _sizeInputEdit->setEnabled(false);
+        _maxDocNumberInputLabel = new QLabel(tr("Maximum number of documents: "));
+        _maxDocNumberInputLabel->setContentsMargins(22, 0, 0, 0);
+        _maxDocNumberInputEdit = new QLineEdit();
+        _maxDocNumberInputEdit->setEnabled(false);
+        _autoIndexCheckBox = new QCheckBox(tr("Auto index _id"), optionsTab);
+        _autoIndexCheckBox->setChecked(true);
+        _usePowerOfTwoSizeCheckBox = new QCheckBox(tr("Use power-of-2 sizes"), optionsTab);
+        // Note: For mongodb 2.6 does not have storageEngine string due to the fact that it uses MMAPV1 only.
+        if (MongoDatabase::StorageEngineType::MMAPV1 == _storageEngine || "" == _storageEngine)
+        {
+            _usePowerOfTwoSizeCheckBox->setChecked(true);
+        }
+        _noPaddingCheckBox = new QCheckBox(tr("No Padding"), optionsTab);
+
+        VERIFY(connect(_cappedCheckBox, SIGNAL(stateChanged(int)),
+            this, SLOT(onCappedCheckBoxChanged(int))));
+
+        QGridLayout *layout = new QGridLayout;
+        layout->addWidget(_cappedCheckBox, 0, 0, 1, 2);
+        layout->addWidget(_sizeInputLabel, 1, 0);
+        layout->addWidget(_sizeInputEdit, 1, 1);
+        layout->addWidget(_maxDocNumberInputLabel, 2, 0);
+        layout->addWidget(_maxDocNumberInputEdit, 2, 1);
+        layout->addWidget(_autoIndexCheckBox, 3, 0);
+        layout->addWidget(_usePowerOfTwoSizeCheckBox, 4, 0);
+        layout->addWidget(_noPaddingCheckBox, 5, 0);
+        layout->setAlignment(Qt::AlignTop);
+        optionsTab->setLayout(layout);
+
+        return optionsTab;
+    }
+
+    QWidget* CreateCollectionDialog::createStorageEngineTab()
+    {
+        QWidget *storageEngineTab = new QWidget(this);
+
+        _storageEngineFrameLabel = new QLabel(tr("Enter the configuration for the storage engine: "));
+        _storageEngineFrame = new JSONFrame(this);
+        configureFrameText(_storageEngineFrame);
+        _storageEngineFrame->sciScintilla()->setText("{\n    \n}");
+        // clear modification state after setting the content
+        _storageEngineFrame->sciScintilla()->setModified(false);
+        VERIFY(connect(_storageEngineFrame->sciScintilla(), SIGNAL(textChanged()),
+            this, SLOT(onFrameTextChanged())));
+
+        QGridLayout *layout = new QGridLayout;
+        layout->addWidget(_storageEngineFrameLabel, 0, 0);
+        layout->addWidget(_storageEngineFrame, 1, 0);
+        layout->setAlignment(Qt::AlignTop);
+        storageEngineTab->setLayout(layout);
+
+        return storageEngineTab;
+    }
+
+    QWidget* CreateCollectionDialog::createValidatorTab()
+    {
+        QWidget *validatorEngineTab = new QWidget(this);
+
+        _validatorLevelLabel = new QLabel(tr("Validation Level: "));
+        _validatorLevelComboBox = new QComboBox();
+        _validatorLevelComboBox->addItem(tr("off"));
+        _validatorLevelComboBox->addItem(tr("strict"));
+        _validatorLevelComboBox->addItem(tr("moderate"));
+        _validatorLevelComboBox->setCurrentIndex(1);
+
+        _validatorActionLabel = new QLabel(tr("Validation Action: "));
+        _validatorActionComboBox = new QComboBox();
+        _validatorActionComboBox->addItem(tr("error"));
+        _validatorActionComboBox->addItem(tr("warn"));
+        _validatorActionComboBox->setCurrentIndex(0);
+
+        _validatorFrameLabel = new QLabel(tr("Enter the validator document for this collection: "));
+        _validatorFrame = new JSONFrame(this);
+        configureFrameText(_validatorFrame);
+        _validatorFrame->sciScintilla()->setText("{\n    \n}");
+        // clear modification state after setting the content
+        _validatorFrame->sciScintilla()->setModified(false);
+        VERIFY(connect(_validatorFrame->sciScintilla(), SIGNAL(textChanged()),
+            this, SLOT(onFrameTextChanged())));
+
+        QHBoxLayout *validationOptionslayout = new QHBoxLayout();
+        validationOptionslayout->addWidget(_validatorLevelLabel);
+        validationOptionslayout->addWidget(_validatorLevelComboBox, Qt::AlignLeft);
+        validationOptionslayout->addWidget(_validatorActionLabel);
+        validationOptionslayout->addWidget(_validatorActionComboBox, Qt::AlignLeft);
+
+        QVBoxLayout *vlayout = new QVBoxLayout();
+        vlayout->addWidget(_validatorFrameLabel);
+        vlayout->addWidget(_validatorFrame);
+
+        QVBoxLayout *layout = new QVBoxLayout();
+        layout->addLayout(validationOptionslayout);
+        layout->addLayout(vlayout);
+        validatorEngineTab->setLayout(layout);
+
+        return validatorEngineTab;
+    }
+
+    QWidget* CreateCollectionDialog::createIndexOptionDefaultsTab()
+    {
+        QWidget *indexOptionDefaultsTab = new QWidget(this);
+
+        _indexOptionDefaultsFrameLabel = new QLabel(tr("Enter a default configuration for indexes when creating a collection: "));
+        _indexOptionDefaultsFrame = new JSONFrame(this);
+        configureFrameText(_indexOptionDefaultsFrame);
+        _indexOptionDefaultsFrame->sciScintilla()->setText("{\n    \n}");
+        // clear modification state after setting the content
+        _indexOptionDefaultsFrame->sciScintilla()->setModified(false);
+        VERIFY(connect(_indexOptionDefaultsFrame->sciScintilla(), SIGNAL(textChanged()),
+            this, SLOT(onFrameTextChanged())));
+
+        QGridLayout *layout = new QGridLayout;
+        layout->addWidget(_indexOptionDefaultsFrameLabel, 0, 0);
+        layout->addWidget(_indexOptionDefaultsFrame, 1, 0);
+        layout->setAlignment(Qt::AlignTop);
+        indexOptionDefaultsTab->setLayout(layout);
+
+        return indexOptionDefaultsTab;
+    }
+
+    void CreateCollectionDialog::saveWindowSettings() const
+    {
+        QSettings settings("Paralect", "Robomongo");
+        settings.setValue("CreateCollectionDialog/size", size());
+    }
+
+    void CreateCollectionDialog::restoreWindowSettings()
+    {
+        QSettings settings("Paralect", "Robomongo");
+        resize(settings.value("CreateCollectionDialog/size").toSize());
+    }
+
+    void CreateCollectionDialog::configureFrameText(JSONFrame* frame)
+    {
+        QsciLexerJavaScript *javaScriptLexer = new JSLexer(this);
+        QFont font = GuiRegistry::instance().font();
+        javaScriptLexer->setFont(font);
+        frame->sciScintilla()->setBraceMatching(QsciScintilla::StrictBraceMatch);
+        frame->sciScintilla()->setFont(font);
+        frame->sciScintilla()->setPaper(QColor(255, 0, 0, 127));
+        frame->sciScintilla()->setLexer(javaScriptLexer);
+        frame->sciScintilla()->setWrapMode((QsciScintilla::WrapMode)QsciScintilla::SC_WRAP_WORD);
+        frame->sciScintilla()->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+        frame->sciScintilla()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+        frame->sciScintilla()->setStyleSheet("QFrame { background-color: rgb(73, 76, 78); border: 1px solid #c7c5c4; border-radius: 4px; margin: 0px; padding: 0px;}");
+    }
+
+    bool CreateCollectionDialog::validate(JSONFrame* frame, mongo::BSONObj& bsonObj, bool silentOnSuccess /* = true */)
+    {
+        try {
+            bsonObj = mongo::Robomongo::fromjson(jsonText(frame).toStdString());
+        }
+        catch (const mongo::Robomongo::ParseMsgAssertionException &ex) {
+            // v0.9
+            QString message = QtUtils::toQString(ex.reason());
+            int offset = ex.offset();
+
+            int line = 0, pos = 0;
+            frame->sciScintilla()->lineIndexFromPosition(offset, &line, &pos);
+            frame->sciScintilla()->setCursorPosition(line, pos);
+
+            int lineHeight = frame->sciScintilla()->lineLength(line);
+            frame->sciScintilla()->fillIndicatorRange(line, pos, line, lineHeight, 0);
+
+            message = QString(tr("Unable to parse JSON:<br /> <b>%1</b>, at (%2, %3)."))
+                .arg(message).arg(line + 1).arg(pos + 1);
+
+            QMessageBox::critical(NULL, tr("Parsing error"), message);
+            frame->setFocus();
+            activateWindow();
+            return false;
+        }
+
+        if (!silentOnSuccess) {
+            QMessageBox::information(NULL, tr("Validation"), tr("JSON is valid!"));
+            frame->setFocus();
+            activateWindow();
+        }
+
+        return true;
+    }
+
+    void CreateCollectionDialog::makeExtraOptionsObj()
+    {
+        mongo::BSONObjBuilder builder;
+
+        if (_autoIndexCheckBox->isEnabled()) builder.append("autoIndexId", isCheckedAutoIndexid()); 
+        if (_noPaddingCheckBox->isEnabled() && _usePowerOfTwoSizeCheckBox->isEnabled()) {
+            builder.append("flags", (isCheckedNoPadding()*2 + isCheckedUsePowerOfTwo()*1));
+        }
+        else if (_noPaddingCheckBox->isEnabled()) {
+            builder.append("flags", (isCheckedNoPadding()*2));
+        }
+        else if (_usePowerOfTwoSizeCheckBox->isEnabled()) {
+            builder.append("flags", (isCheckedUsePowerOfTwo()*1));
+        }
+        if (_advancedOptions->isTabEnabled(STORAGE_ENGINE_TAB) ) {
+            validate(_storageEngineFrame, _storageEngineObj);
+            if(!_storageEngineObj.isEmpty()) builder.append("storageEngine", _storageEngineObj);
+        }
+        if (_advancedOptions->isTabEnabled(VALIDATOR_TAB)) {
+            validate(_validatorFrame, _validatorObj);
+            if (!_validatorObj.isEmpty()) {
+                builder.append("validator", _validatorObj);
+                builder.append("validationLevel", _validatorLevelComboBox->currentText().toStdString());
+                builder.append("validationAction", _validatorActionComboBox->currentText().toStdString());
+            }
+        }
+        if (_advancedOptions->isTabEnabled(INDEX_OPTION_DEFAULTS_TAB)) {
+            validate(_indexOptionDefaultsFrame, _indexOptionDefaultsObj);
+            if (!_indexOptionDefaultsObj.isEmpty()) builder.append("indexOptionDefaults", _indexOptionDefaultsObj);
+        }
+        // Complete and get resulting BSONObj
+        _extraOptionsObj = builder.obj();
+    }
+
+    bool CreateCollectionDialog::validateOptionDependencies() const
+    {
+        bool result(false);
+        // Validate capped options
+        if (isCapped()) {
+            if (!(getSizeInputValue() > 0)) {
+                QMessageBox::critical(NULL, tr("Error"), tr("Maximum size is required for capped collections"));
+                return false;
+            }
+            result = true;
+        }
+        else {
+            result = true;
+        }
+
+        // Completed checking all dependendencies.
+        return result;
+    }
+    
+    void CreateCollectionDialog::disableUnsupportedOptions() const
+    {
+
+        // Handle WIRED_TIGER engine type
+        if (MongoDatabase::StorageEngineType::WIRED_TIGER == _storageEngine) {
+            disableOption(_usePowerOfTwoSizeCheckBox, USE_POWEROFTWO_HINT);
+            disableOption(_noPaddingCheckBox, NO_PADDING_HINT);
+            if (MongoDatabase::DBVersion::MONGODB_3_0 > _dbVersion) {
+                disableTab(STORAGE_ENGINE_TAB, STORAGE_ENGINE_TAB_HINT);
+            }
+        }
+        else {
+            disableTab(STORAGE_ENGINE_TAB, STORAGE_ENGINE_TAB_HINT);
+        }
+
+        // Handle MMAPV1 engine type
+        // Note: For mongodb 2.6 does not have storageEngine string due to the fact that it uses MMAPV1 only.
+        if (MongoDatabase::StorageEngineType::MMAPV1 == _storageEngine || "" == _storageEngine) {
+            if (MongoDatabase::DBVersion::MONGODB_3_0 < _dbVersion) {
+                _usePowerOfTwoSizeCheckBox->hide();
+            }
+            if (MongoDatabase::DBVersion::MONGODB_3_0 > _dbVersion) {
+                disableOption(_noPaddingCheckBox, NO_PADDING_HINT);
+            }
+        }
+
+        if (MongoDatabase::DBVersion::MONGODB_3_2 < _dbVersion) {
+            disableOption(_autoIndexCheckBox, AUTO_INDEXID_HINT);
+        }
+
+        if (MongoDatabase::DBVersion::MONGODB_3_0 > _dbVersion) {
+            disableTab(STORAGE_ENGINE_TAB, STORAGE_ENGINE_TAB_HINT);
+        }
+        if (MongoDatabase::DBVersion::MONGODB_3_2 > _dbVersion) {
+            disableTab(VALIDATOR_TAB, VALIDATOR_TAB_HINT);
+            disableTab(INDEX_OPTION_DEFAULTS_TAB, INDEX_OPTION_DEFAULTS_TAB_HINT);
+        }
+    }
+
+    void CreateCollectionDialog::disableOption(QWidget* option, const QString& hint) const
+    {
+        option->setDisabled(true);
+        option->setToolTip(hint);
+    }
+
+    void CreateCollectionDialog::disableTab(int index, const QString& hint) const
+    {
+        _advancedOptions->setTabEnabled(index, false);
+        _advancedOptions->setTabToolTip(index, hint);
+    }
+
+    void CreateCollectionDialog::setCursorPosition(int line, int column)
+    {
+        _activeFrame->sciScintilla()->setCursorPosition(line, column);
+    }
+
+    QString CreateCollectionDialog::jsonText(JSONFrame* frame) const
+    {
+        return frame->sciScintilla()->text().trimmed();
+    }
+}

src/robomongo/gui/dialogs/CreateCollectionDialog.h

@@ -0,0 +1,309 @@
+#pragma once
+
+#include <mongo/bson/bsonobj.h>
+#include <QDialog>
+
+QT_BEGIN_NAMESPACE
+class QLabel;
+class QDialogButtonBox;
+class QLineEdit;
+class QTabWidget;
+class QCheckBox;
+class QComboBox;
+QT_END_NAMESPACE
+class QsciScintilla;
+
+namespace Robomongo
+{
+    class FindFrame;
+    class Indicator;
+
+    /**
+    * @brief This Dialog allows to create collection with selective options.
+    */
+    class CreateCollectionDialog : public QDialog
+    {
+        Q_OBJECT
+
+    public:
+        using JSONFrame = FindFrame;
+        
+        /**
+        * @brief Construct dialog with parameters
+        * @param serverName: Database name
+        * @param dbVersion: Database version
+        * @param storageEngine: Storage engine type
+        * @param database: Name of the database
+        * @param collection: Name of the collection
+        */
+        explicit CreateCollectionDialog(const QString &serverName, const float dbVersion, const std::string& storageEngine, 
+            const QString &database = QString(), const QString &collection = QString(), QWidget *parent = 0);
+
+        /**
+        * @brief Used if dialog exec() method returns QDialog::Accepted 
+        * @return Extra options as BSONObj
+        */
+        const mongo::BSONObj getExtraOptions() const;
+
+        /**
+        * @return Collection name
+        */
+        QString getCollectionName() const;
+
+        /**
+        * @return true if capped option checked, false otherwise
+        */
+        bool isCapped() const;
+
+        /**
+        * @return Size option input
+        */
+        long long getSizeInputValue() const;
+
+        /**
+        * @return Max number of documents option input
+        */
+        int getMaxDocNumberInputValue() const;
+
+        /**
+        * @return true if auto index_id option checked, false otherwise
+        */
+        bool isCheckedAutoIndexid() const;
+        
+        /**
+        * @return true if use power-of-2 sizes option checked, false otherwise
+        */
+        bool isCheckedUsePowerOfTwo() const;
+        
+        /**
+        * @return true if no padding option checked, false otherwise
+        */
+        bool isCheckedNoPadding() const;
+
+    public Q_SLOTS:
+        /**
+        * @brief Validate all input fields and make extraOptions object if all valid when create button clicked.
+        */
+        virtual void accept();
+
+        /**
+        * @brief Called when "Cancel" button clicked.
+        */
+        virtual void reject();
+
+    protected:
+        /**
+        * @brief Reimplementing closeEvent in order to do implement functioanlites before close this dialog.
+        */
+        void closeEvent(QCloseEvent *event);
+
+    private Q_SLOTS:
+        /**
+        * @brief Set indicator position when active JSON frame text changed
+        */
+        void onFrameTextChanged();
+
+        /**
+        * @brief Validate active JSON frame text when validate button clicked
+        */
+        void onValidateButtonClicked();
+
+        /**
+        * @brief Enable create button if input edit has text
+        * @param text : string from _inputEdit widget
+        */
+        void enableCreateButton(const QString &text);
+
+        /**
+        * @brief Enable/disable capped options when capped checkbox state changed
+        * @param newState : New state of capped checkbox
+        */
+        void onCappedCheckBoxChanged(int newState);
+
+        /**
+        * @brief Show/hide validate JSON button, update active JSON frame and object according to active tab
+        * @param Index of active tab (i.e. index = 0 for the first tab)
+        */
+        void onTabChanged(int index);
+
+        /**
+        * @brief Show/hide advanced options menu (_tabwidget) when advancedButton toggled.
+        * @param state : true if dialog is expanding, false if shrinking.
+        */
+        void onAdvancedButtonToggled(bool state);
+
+    private:
+        /**
+        * @brief Tool tip strings for disabled options and tabs
+        */
+        static const QString STORAGE_ENGINE_TAB_HINT;
+        static const QString VALIDATOR_TAB_HINT;
+        static const QString INDEX_OPTION_DEFAULTS_TAB_HINT;
+        static const QString NO_PADDING_HINT;
+        static const QString USE_POWEROFTWO_HINT;
+        static const QString AUTO_INDEXID_HINT;
+
+        /**
+        * @brief Create database indicator widget
+        * @param database : Name of the database
+        * @return : Pointer to newly created Indicator
+        */
+        Indicator* createDatabaseIndicator(const QString &database);
+
+        /**
+        * @brief Create collection indicator widget
+        * @param database : Name of the collection
+        * @return : Pointer to newly created Indicator
+        */
+        Indicator* createCollectionIndicator(const QString &collection);
+
+        /**
+        * @brief Creators for the tabs
+        * @return : Pointer to newly created tab
+        */
+        QWidget* createOptionsTab();
+        QWidget* createStorageEngineTab();
+        QWidget* createValidatorTab();
+        QWidget* createIndexOptionDefaultsTab();
+
+        /**
+        * @brief Save windows settings into system registry
+        */
+        void saveWindowSettings() const;
+        /**
+        * @brief Restore windows settings from system registry
+        */
+        void restoreWindowSettings();
+
+        /**
+        * @brief Do initial configuration of given JSON frame.
+        * @param frame : Pointer to newly created tab
+        */
+        void configureFrameText(JSONFrame* frame);
+
+        /**
+        * @brief Build extraOptions BSON Object
+        */ 
+        void makeExtraOptionsObj();
+        
+        /**
+        * @brief Validate dependencies and requirements between all inputs
+        * @return : true if all options valid, false at least one dependency not met
+        */
+        bool validateOptionDependencies() const;
+
+        /**
+        * @brief Disable options if they are not supported by database version or storage engine type
+        */
+        void disableUnsupportedOptions() const;
+
+        /**
+        * @brief Disable widget if unsupported
+        * @param option : Widget to disable
+        * @param hint : Hint string to be shown
+        */
+        void disableOption(QWidget* option, const QString& hint) const;
+        
+        /**
+        * @brief Disable tab if unsupported
+        * @param index : Tab index
+        * @param hint : Hint string to be shown
+        */
+        void disableTab(int index, const QString& hint) const;
+
+        /**
+        * @brief Set cursor position of the active JSON frame
+        * @param line :  Line number 
+        * @param column : Column number
+        */
+        void setCursorPosition(int line, int column);
+
+        /**
+        * @return : String from given JSON frame
+        * @param frame : Pointer to JSON frame
+        */
+        QString jsonText(JSONFrame* frame) const;
+
+        /**
+        * @brief Do JSON validation/creation for given frame text
+        * @param frame : Pointer to JSON frame
+        * @param bsonObj : BSON object to be validated
+        * @param silentOnSuccess : true for silent validation, false for message box on validation
+        * @return true if text is valid JSON, false otherwise
+        */
+        bool validate(JSONFrame* frame, mongo::BSONObj& bsonObj, bool silentOnSuccess = true);
+
+        /**
+        * @brief Main Window 
+        */
+        QLineEdit *_inputEdit;
+        QLabel *_inputLabel;
+        QTabWidget *_advancedOptions;
+        QPushButton *_validateJsonButton;
+        QDialogButtonBox *_buttonBox;
+        QPushButton *_advancedButton;
+
+        /**
+        * @brief Options Tab
+        */
+        QCheckBox *_cappedCheckBox;
+        QLabel *_sizeInputLabel;
+        QLineEdit *_sizeInputEdit;
+        QLabel *_maxDocNumberInputLabel;
+        QLineEdit *_maxDocNumberInputEdit;
+        QCheckBox *_autoIndexCheckBox;
+        QCheckBox *_usePowerOfTwoSizeCheckBox;
+        QCheckBox *_noPaddingCheckBox;
+        /**
+        * @brief Storage Engine Tab
+        */
+        JSONFrame *_storageEngineFrame;
+        QLabel * _storageEngineFrameLabel;
+        /**
+        * @brief Validator Tab
+        */
+        QLabel * _validatorLevelLabel;
+        QComboBox * _validatorLevelComboBox;
+        QLabel * _validatorActionLabel;
+        QComboBox * _validatorActionComboBox;
+        JSONFrame *_validatorFrame;
+        QLabel * _validatorFrameLabel;
+        /**
+        * @brief Index Options Defaults Tab
+        */
+        JSONFrame *_indexOptionDefaultsFrame;
+        QLabel * _indexOptionDefaultsFrameLabel;
+
+        /**
+        * @brief Pointer to active tab's frame
+        */
+        JSONFrame *_activeFrame;         
+
+        /**
+        * @brief Pointer to active tab's BSON obj.
+        */
+        mongo::BSONObj *_activeObj;
+
+        /**
+        * @brief Main BSON obj. with all extra options
+        */
+        mongo::BSONObj _extraOptionsObj;
+
+        /**
+        * @brief Sub objects for each JSON tab to create extraOptions object finally.
+        */
+        mongo::BSONObj _storageEngineObj;
+        mongo::BSONObj _validatorObj;
+        mongo::BSONObj _indexOptionDefaultsObj;
+
+        /**
+        * @brief Database version
+        */
+        const float _dbVersion;
+
+        /**
+        * @brief Storage engine type
+        */
+        const std::string _storageEngine;
+    };
+}

src/robomongo/gui/dialogs/CreateDatabaseDialog.cpp

@@ -13,7 +13,7 @@
 
 namespace Robomongo
 {
-    const QSize CreateDatabaseDialog::dialogSize = QSize(300,150);
+    const QSize CreateDatabaseDialog::dialogSize = QSize(300, 150);
 
     CreateDatabaseDialog::CreateDatabaseDialog(const QString &serverName, const QString &database,
                                                const QString &collection, QWidget *parent) :
@@ -31,7 +31,7 @@ namespace Robomongo
         hline->setFrameShadow(QFrame::Sunken);
 
         _inputEdit = new QLineEdit();
-        _inputLabel= new QLabel("Database Name:");
+        _inputLabel = new QLabel("Database Name:");
         _inputEdit->setMaxLength(maxLenghtName);
 
         _buttonBox = new QDialogButtonBox(this);

src/robomongo/gui/dialogs/CreateUserDialog.cpp

@@ -17,8 +17,19 @@
 
 namespace Robomongo
 {
-    const char * rolesText[CreateUserDialog::RolesCount] = {"read","readWrite","dbAdmin","userAdmin","clusterAdmin","readAnyDatabase","readWriteAnyDatabase","userAdminAnyDatabase","dbAdminAnyDatabase"}; 
-    const QSize CreateUserDialog::minimumSize = QSize(400,200);
+    const char * rolesText[CreateUserDialog::RolesCount] = {
+        "read",
+        "readWrite",
+        "dbAdmin",
+        "userAdmin",
+        "clusterAdmin",
+        "readAnyDatabase",
+        "readWriteAnyDatabase",
+        "userAdminAnyDatabase",
+        "dbAdminAnyDatabase"
+    };
+
+    const QSize CreateUserDialog::minimumSize = QSize(400, 200);
 
     bool containsWord(const std::string& sentence, const std::string& word)
     {
@@ -31,7 +42,7 @@ namespace Robomongo
                 if (pos) {
                     isFirstAlpha = isalpha(sentence[pos - 1]);
                 }
-                if (!isFirstAlpha&&!isLastAlpha)
+                if (!isFirstAlpha && !isLastAlpha)
                     return true;
             }
             pos++;
@@ -39,13 +50,11 @@ namespace Robomongo
         return false;
     }
 
-    CreateUserDialog::CreateUserDialog(const QStringList &databases,const QString &serverName,
+    CreateUserDialog::CreateUserDialog(const QStringList &databases, const QString &serverName,
                                        const QString &database, const MongoUser &user,
                                        QWidget *parent) : QDialog(parent),
         _user(user)
     {
-        VERIFY(!user.version() < MongoUser::minimumSupportedVersion);
-
         setWindowTitle("Add User");
         setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint); // Remove help button (?)
         setMinimumSize(minimumSize);
@@ -57,10 +66,10 @@ namespace Robomongo
         hline->setFrameShape(QFrame::HLine);
         hline->setFrameShadow(QFrame::Sunken);
 
-        _userNameLabel= new QLabel("Name:");
+        _userNameLabel = new QLabel("Name:");
         _userNameEdit = new QLineEdit();
         _userNameEdit->setText(QtUtils::toQString(user.name()));
-        _userPassLabel= new QLabel("Password:");
+        _userPassLabel = new QLabel("Password:");
         _userPassEdit = new QLineEdit();
         _userPassEdit->setEchoMode(QLineEdit::Password);
         _userSourceLabel = new QLabel("UserSource:");
@@ -70,14 +79,14 @@ namespace Robomongo
 
         QGridLayout *gridRoles = new QGridLayout();
         MongoUser::RoleType userRoles = user.role();
-        for (unsigned i=0; i<RolesCount; ++i)
+        for (unsigned i = 0; i<RolesCount; ++i)
         {
             int row = i%3;
             int col = i/3;
-            _rolesArray[i] = new QCheckBox(rolesText[i],this);
-            MongoUser::RoleType::const_iterator it = std::find(userRoles.begin(),userRoles.end(),rolesText[i]);
-            _rolesArray[i]->setChecked(it!=userRoles.end());      
-            gridRoles->addWidget(_rolesArray[i],row,col);
+            _rolesArray[i] = new QCheckBox(rolesText[i], this);
+            MongoUser::RoleType::const_iterator it = std::find(userRoles.begin(), userRoles.end(), rolesText[i]);
+            _rolesArray[i]->setChecked(it!= userRoles.end());
+            gridRoles->addWidget(_rolesArray[i], row, col);
         }
 
         QDialogButtonBox *buttonBox = new QDialogButtonBox(this);
@@ -120,7 +129,6 @@ namespace Robomongo
         QWidget *parent) : QDialog(parent),
         _user(user)
     {
-        VERIFY(user.version() < MongoUser::minimumSupportedVersion);
         setWindowTitle("Add User");
         setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint); // Remove help button (?)
         setMinimumSize(minimumSize);
@@ -132,7 +140,7 @@ namespace Robomongo
         hline->setFrameShape(QFrame::HLine);
         hline->setFrameShadow(QFrame::Sunken);
 
-        _userNameLabel= new QLabel("Name:");
+        _userNameLabel = new QLabel("Name:");
         _userNameEdit = new QLineEdit();
         _userNameEdit->setText(QtUtils::toQString(user.name()));
         _userPassLabel= new QLabel("Password:");

src/robomongo/gui/dialogs/DocumentTextEditor.cpp

@@ -36,10 +36,6 @@ namespace Robomongo
 
         resize(size);
 
-        int x = (screenGeometry.width() - width()) / 2;
-        int y = (screenGeometry.height() - height()) / 2;
-        move(x, y);
-
         setWindowFlags(Qt::Window | Qt::WindowMaximizeButtonHint | Qt::WindowCloseButtonHint);
 
         Indicator *collectionIndicator = new Indicator(GuiRegistry::instance().collectionIcon(), QtUtils::toQString(_info._ns.collectionName()));
@@ -144,18 +140,18 @@ namespace Robomongo
             int jsonLen = textString.length();
             int offset = 0;
             _obj.clear();
-            while(offset!=jsonLen)
+            while (offset != jsonLen)
             {
-                mongo::BSONObj doc = mongo::Robomongo::fromjson(json+offset,&len);
+                mongo::BSONObj doc = mongo::Robomongo::fromjson(json+offset, &len);
                 _obj.push_back(doc);
-                offset+=len;
+                offset += len;
             }
         } catch (const mongo::Robomongo::ParseMsgAssertionException &ex) {
 //            v0.9
             QString message = QtUtils::toQString(ex.reason());
             int offset = ex.offset();
 
-            int line=0, pos=0;
+            int line = 0, pos = 0;
             _queryText->sciScintilla()->lineIndexFromPosition(offset, &line, &pos);
             _queryText->sciScintilla()->setCursorPosition(line, pos);
 
@@ -198,7 +194,7 @@ namespace Robomongo
         QsciLexerJavaScript *javaScriptLexer = new JSLexer(this);
         QFont font = GuiRegistry::instance().font();
         javaScriptLexer->setFont(font);
-        _queryText->sciScintilla()->setBraceMatching(QsciScintilla::StrictBraceMatch);
+        _queryText->sciScintilla()->setAppropriateBraceMatching();
         _queryText->sciScintilla()->setFont(font);
         _queryText->sciScintilla()->setPaper(QColor(255, 0, 0, 127));
         _queryText->sciScintilla()->setLexer(javaScriptLexer);

src/robomongo/gui/dialogs/FunctionTextEditor.cpp

@@ -97,7 +97,7 @@ namespace Robomongo
         const QFont &textFont = GuiRegistry::instance().font();
         QsciLexerJavaScript *javaScriptLexer = new JSLexer(this);
         javaScriptLexer->setFont(textFont);        
-        _queryText->sciScintilla()->setBraceMatching(QsciScintilla::StrictBraceMatch);
+        _queryText->sciScintilla()->setAppropriateBraceMatching();
         _queryText->sciScintilla()->setFont(textFont);
         _queryText->sciScintilla()->setPaper(QColor(255, 0, 0, 127));
         _queryText->sciScintilla()->setLexer(javaScriptLexer);

src/robomongo/gui/dialogs/PreferencesDialog.cpp

@@ -24,7 +24,7 @@ namespace Robomongo
 
         setWindowTitle("Preferences " PROJECT_NAME_TITLE);
         setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
-        setFixedSize(height,width);
+        setFixedSize(height, width);
 
         QVBoxLayout *layout = new QVBoxLayout(this);
 
@@ -33,7 +33,7 @@ namespace Robomongo
         defLayout->addWidget(defDisplayModeLabel);
         _defDisplayModeComboBox = new QComboBox();
         QStringList modes;
-        for (int i = Text;i<=Custom;++i)
+        for (int i = Text; i <= Custom; ++i)
         {
             modes.append(convertViewModeToString(static_cast<ViewMode>(i)));
         }
@@ -46,7 +46,7 @@ namespace Robomongo
         timeZoneLayout->addWidget(timeZoneLabel);
         _timeZoneComboBox = new QComboBox();
         QStringList times;
-        for (int i = Utc;i<=LocalTime;++i)
+        for (int i = Utc; i <= LocalTime; ++i)
         {
             times.append(convertTimesToString(static_cast<SupportedTimes>(i)));
         }
@@ -59,7 +59,7 @@ namespace Robomongo
         uuidEncodingLayout->addWidget(uuidEncodingLabel);
         _uuidEncodingComboBox = new QComboBox();
         QStringList uuids;
-        for (int i = DefaultEncoding;i<=PythonLegacy;++i)
+        for (int i = DefaultEncoding; i <= PythonLegacy; ++i)
         {
             uuids.append(convertUUIDEncodingToString(static_cast<UUIDEncoding>(i)));
         }

src/robomongo/gui/dialogs/SSHTunnelTab.cpp

@@ -9,12 +9,25 @@
 #include <QPushButton>
 #include <QFileDialog>
 #include <QComboBox>
+#include <QMessageBox>
+#include <QFileInfo>
 #include <QFrame>
 
 #include "robomongo/core/utils/QtUtils.h"
+#include "robomongo/gui/GuiRegistry.h"
 #include "robomongo/gui/utils/ComboBoxUtils.h"
 #include "robomongo/core/settings/ConnectionSettings.h"
 #include "robomongo/core/settings/SshSettings.h"
+#include "robomongo/gui/utils/GuiConstants.h"
+
+namespace {
+    const QString askPasswordText = "Ask for password each time";
+    const QString askPassphraseText = "Ask for passphrase each time";
+    bool isFileExists(const QString &path) {
+        QFileInfo fileInfo(path);
+        return fileInfo.exists() && fileInfo.isFile();
+    }
+}
 
 namespace Robomongo
 {
@@ -26,12 +39,16 @@ namespace Robomongo
         _sshSupport->setStyleSheet("margin-bottom: 7px");
         _sshSupport->setChecked(info->enabled());
 
+        _askForPassword = new QCheckBox(askPasswordText);
+        _askForPassword->setChecked(info->askPassword());
+        VERIFY(connect(_askForPassword, SIGNAL(stateChanged(int)), this, SLOT(askForPasswordStateChanged(int))));
+
         _sshHostName = new QLineEdit(QtUtils::toQString(info->host()));
         _userName = new QLineEdit(QtUtils::toQString(info->userName()));
 
         _sshPort = new QLineEdit(QString::number(info->port()));
-        _sshPort->setFixedWidth(80);
-        QRegExp rx("\\d+");//(0-65554)
+        _sshPort->setFixedWidth(40);
+        QRegExp rx("\\d+"); //(0-65554)
         _sshPort->setValidator(new QRegExpValidator(rx, this));        
 
         _security = new QComboBox();
@@ -40,14 +57,16 @@ namespace Robomongo
 
         _passwordBox = new QLineEdit(QtUtils::toQString(info->userPassword()));
         _passwordBox->setEchoMode(QLineEdit::Password);
-        _passwordEchoModeButton = new QPushButton(tr("Show"));
+        _passwordEchoModeButton = new QPushButton;
+        _passwordEchoModeButton->setIcon(GuiRegistry::instance().hideIcon());
         VERIFY(connect(_passwordEchoModeButton, SIGNAL(clicked()), this, SLOT(togglePasswordEchoMode())));
-        
+
         _privateKeyBox = new QLineEdit(QtUtils::toQString(info->privateKeyFile()));
         
         _passphraseBox = new QLineEdit(QtUtils::toQString(info->passphrase()));
         _passphraseBox->setEchoMode(QLineEdit::Password);
-        _passphraseEchoModeButton = new QPushButton(tr("Show"));
+        _passphraseEchoModeButton = new QPushButton;
+        _passphraseEchoModeButton->setIcon(GuiRegistry::instance().hideIcon());
         VERIFY(connect(_passphraseEchoModeButton, SIGNAL(clicked()), this, SLOT(togglePassphraseEchoMode())));
 
         _passwordLabel = new QLabel("User Password:");
@@ -103,6 +122,7 @@ namespace Robomongo
         connectionLayout->addWidget(_sshPassphraseLabel,           8, 0);
         connectionLayout->addWidget(_passphraseBox,                8, 1);
         connectionLayout->addWidget(_passphraseEchoModeButton,     8, 2);
+        connectionLayout->addWidget(_askForPassword,               9, 1, 1, 2);
 
         QVBoxLayout *mainLayout = new QVBoxLayout;
         mainLayout->addWidget(_sshSupport);
@@ -122,32 +142,70 @@ namespace Robomongo
         VERIFY(connect(_sshSupport, SIGNAL(stateChanged(int)), this, SLOT(sshSupportStateChange(int))));
 
         _sshHostName->setFocus();
+
+#ifdef Q_OS_MAC
+        _passwordEchoModeButton->setMaximumWidth(_selectPrivateFileButton->width());
+        _passphraseEchoModeButton->setMaximumWidth(_selectPrivateFileButton->width());
+#else
+        _passwordEchoModeButton->setMinimumWidth(_selectPrivateFileButton->width());
+        _passphraseEchoModeButton->setMinimumWidth(_selectPrivateFileButton->width());
+#endif
+        // Attempt to fix the issue for Windows High DPI button height is slightly taller than other widgets 
+#ifdef Q_OS_WIN
+        _passwordEchoModeButton->setMaximumHeight(HighDpiContants::WIN_HIGH_DPI_BUTTON_HEIGHT);
+        _passphraseEchoModeButton->setMaximumHeight(HighDpiContants::WIN_HIGH_DPI_BUTTON_HEIGHT);
+        _selectPrivateFileButton->setMaximumHeight(HighDpiContants::WIN_HIGH_DPI_BUTTON_HEIGHT);
+#endif
+
     }
 
-    bool SshTunnelTab::isSshSupported() const
+    bool SshTunnelTab::sshEnabled() const
     {
         return _sshSupport->isChecked();
     }
 
-    void SshTunnelTab::sshSupportStateChange(int value)
+    void SshTunnelTab::setPasswordFieldsEnabled(bool enabled)
     {
-        _sshHostName->setEnabled(value);
-        _userName->setEnabled(value);
-        _sshPort->setEnabled(value);       
-        _security->setEnabled(value);
+        _sshPassphraseLabel->setEnabled(enabled);
+        _passphraseBox->setEnabled(enabled);
+        _passwordBox->setEnabled(enabled);
+        _passwordLabel->setEnabled(enabled);
+        _passphraseEchoModeButton->setEnabled(enabled);
+        _passwordEchoModeButton->setEnabled(enabled);
+    }
 
-        _sshPrivateKeyLabel->setEnabled(value);
-        _privateKeyBox->setEnabled(value);
-        _selectPrivateFileButton->setEnabled(value);
-        _sshAddressLabel->setEnabled(value);
-        _sshUserNameLabel->setEnabled(value);
-        _sshAuthMethodLabel->setEnabled(value);
+    void SshTunnelTab::askForPasswordStateChanged(int state)
+    {
+        bool checked = state == Qt::Checked;
+        if (checked) {
+            _passphraseBox->setText("");
+            _passwordBox->setText("");
+        }
 
-        _sshPassphraseLabel->setEnabled(value);
-        _passphraseBox->setEnabled(value);
+        setPasswordFieldsEnabled(!checked && _sshSupport->isChecked());
+    }
 
-        _passwordBox->setEnabled(value);
-        _passwordLabel->setEnabled(value);
+    void SshTunnelTab::sshSupportStateChange(int state)
+    {
+        bool checked = state == Qt::Checked;
+        _sshHostName->setEnabled(checked);
+        _userName->setEnabled(checked);
+        _sshPort->setEnabled(checked);
+        _security->setEnabled(checked);
+
+        _sshPrivateKeyLabel->setEnabled(checked);
+        _privateKeyBox->setEnabled(checked);
+        _selectPrivateFileButton->setEnabled(checked);
+        _sshAddressLabel->setEnabled(checked);
+        _sshUserNameLabel->setEnabled(checked);
+        _sshAuthMethodLabel->setEnabled(checked);
+
+        _askForPassword->setEnabled(checked);
+
+        askForPasswordStateChanged(_askForPassword->checkState());
+
+        if (checked)
+            _sshHostName->setFocus();
     }
 
     void SshTunnelTab::securityChange(const QString& method)
@@ -165,6 +223,7 @@ namespace Robomongo
         _passwordBox->setVisible(!isKey);
         _passwordLabel->setVisible(!isKey);
         _passwordEchoModeButton->setVisible(!isKey);
+        _askForPassword->setText(isKey ? askPassphraseText : askPasswordText);
     }
 
     void SshTunnelTab::setPrivateFile()
@@ -196,37 +255,56 @@ namespace Robomongo
 //        return SSHInfo::PASSWORD;
 //    }
 
-    void SshTunnelTab::accept()
+    bool SshTunnelTab::accept()
     {
+        bool sshEnabled = _sshSupport->isChecked();
+        QString authMethod = _security->currentText() == "Private Key" ? "publickey" : "password";
+
+        // Check for existence of the private key file name
+        // and try to expand "~" character when needed
+        QString privateKey = _privateKeyBox->text();
+        if (sshEnabled && authMethod == "publickey" &&  !isFileExists(privateKey)) {
+            bool failed = true;
+
+            // Try to expand "~" if available
+            if (privateKey.startsWith ("~/")) {
+                privateKey.replace (0, 1, QDir::homePath());
+                if (isFileExists(privateKey)) {
+                    failed = false;
+                }
+            }
+
+            if (failed) {
+                QString message = QString("Private key file \"%1\" doesn't exist").arg(privateKey);
+                QMessageBox::information(this, "Settings are incomplete", message);
+                return false;
+            }
+        }
+
         SshSettings *info = _settings->sshSettings();
         info->setHost(QtUtils::toStdString(_sshHostName->text()));
         info->setPort(_sshPort->text().toInt());
         info->setUserName(QtUtils::toStdString(_userName->text()));
         info->setUserPassword(QtUtils::toStdString(_passwordBox->text()));
-//        info->setPublicKeyFile("");
-        info->setPrivateKeyFile(QtUtils::toStdString(_privateKeyBox->text()));
+        info->setAskPassword(_askForPassword->isChecked());
+        info->setPrivateKeyFile(QtUtils::toStdString(privateKey));
         info->setPassphrase(QtUtils::toStdString(_passphraseBox->text()));
-
-        if (_security->currentText() == "Private Key") {
-            info->setAuthMethod("publickey");
-        } else {
-            info->setAuthMethod("password");
-        }
-
-        info->setEnabled(_sshSupport->isChecked());
+        info->setAuthMethod(QtUtils::toStdString(authMethod));
+        info->setEnabled(sshEnabled);
+        return true;
     }
     
     void SshTunnelTab::togglePasswordEchoMode()
     {
         bool isPassword = _passwordBox->echoMode() == QLineEdit::Password;
         _passwordBox->setEchoMode(isPassword ? QLineEdit::Normal: QLineEdit::Password);
-        _passwordEchoModeButton->setText(isPassword ? tr("Hide"): tr("Show"));
+        _passwordEchoModeButton->setIcon(isPassword ? GuiRegistry::instance().showIcon() : GuiRegistry::instance().hideIcon());
     }
     
     void SshTunnelTab::togglePassphraseEchoMode()
     {
         bool isPassword = _passphraseBox->echoMode() == QLineEdit::Password;
         _passphraseBox->setEchoMode(isPassword ? QLineEdit::Normal: QLineEdit::Password);
-        _passphraseEchoModeButton->setText(isPassword ? tr("Hide"): tr("Show"));
+        _passphraseEchoModeButton->setIcon(isPassword ? GuiRegistry::instance().showIcon() : GuiRegistry::instance().hideIcon());
     }
 }

src/robomongo/gui/dialogs/SSHTunnelTab.h

@@ -23,21 +23,27 @@ namespace Robomongo
 
     public:
         SshTunnelTab(ConnectionSettings *settings);
-        void accept();
-        bool isSshSupported() const;
+        bool accept();
+
+        /**
+        * @return true if use SSH checkbox is checked, false otherwise
+        */
+        bool sshEnabled() const;
 
     private Q_SLOTS:
-        void sshSupportStateChange(int val);
+        void sshSupportStateChange(int checked);
+        void askForPasswordStateChanged(int checked);
         void securityChange(const QString& val);
         void setPrivateFile();
         void togglePasswordEchoMode();
         void togglePassphraseEchoMode();
 
     private:
-//        SSHInfo::SupportedAuthenticationMetods selectedAuthMethod();
-        
+        void setPasswordFieldsEnabled(bool enabled);
+
     private:        
         QCheckBox *_sshSupport;
+        QCheckBox *_askForPassword;
         QLineEdit *_sshHostName;
         QLineEdit *_userName;
         QLineEdit *_sshPort;

src/robomongo/gui/dialogs/SSLTab.cpp

@@ -0,0 +1,410 @@
+#include "robomongo/gui/dialogs/SSLTab.h"
+
+#include <QApplication>
+#include <QLabel>
+#include <QLineEdit>
+#include <QGridLayout>
+#include <QCheckBox>
+#include <QPushButton>
+#include <QFileDialog>
+#include <QComboBox>
+#include <QRadioButton>
+#include <QFileInfo>
+#include <QMessageBox>
+
+#include <mongo/util/net/ssl_options.h>
+#include <mongo/util/net/ssl_manager.h>
+
+#include "robomongo/core/utils/QtUtils.h"
+#include "robomongo/core/settings/ConnectionSettings.h"
+#include "robomongo/core/settings/SshSettings.h"
+#include "robomongo/core/settings/SslSettings.h"
+#include "robomongo/gui/GuiRegistry.h"
+#include "robomongo/gui/utils/ComboBoxUtils.h"
+#include "robomongo/gui/utils/GuiConstants.h"
+
+namespace 
+{
+    // Helper function: Check file existence, return true if file exists, false otherwise
+    bool fileExists(const QString &path) 
+    {
+        QFileInfo fileInfo(path);
+        return (fileInfo.exists() && fileInfo.isFile());
+    }
+
+    // Helper hint strings
+    QString const CA_FILE_HINT                      = " mongo --sslCAFile : Certificate Authority file for SSL";
+    QString const PEM_FILE_HINT                     = " mongo --sslPEMKeyFile : PEM certificate/key file for SSL";
+    QString const PEM_PASS_HINT                     = " mongo --sslPEMKeyPassword : password for key in PEM file for SSL";
+    QString const ALLOW_INVALID_HOSTNAME_HINT       = " mongo --sslAllowInvalidHostnames : allow connections to servers"
+                                                      " with non-matching hostnames";
+    QString const ALLOW_INVALID_CERTIFICATES_HINT   = " mongo --sslAllowInvalidCertificates : allow connections to servers"
+                                                      " with invalid certificates";
+    QString const CRL_FILE_HINT                     = " mongo --sslCRLFile : Certificate Revocation List file for SSL";
+}
+
+namespace Robomongo
+{
+    SSLTab::SSLTab(ConnectionSettings *connSettings) 
+        : _connSettings(connSettings)
+    {
+        const SslSettings* const sslSettings = _connSettings->sslSettings();
+
+        // Use SSL section
+        _useSslCheckBox = new QCheckBox("Use SSL protocol");
+        _useSslCheckBox->setStyleSheet("margin-bottom: 7px");
+        VERIFY(connect(_useSslCheckBox, SIGNAL(stateChanged(int)), this, SLOT(useSslCheckBoxStateChange(int))));
+
+        // Auth. Method section
+        _authMethodLabel = new QLabel("Authentication Method: ");
+        _authMethodComboBox = new QComboBox;
+        _authMethodComboBox->addItem("Self-signed Certificate");
+        _authMethodComboBox->addItem("Use CA Certificate");
+        _authMethodComboBox->setItemData(0, ALLOW_INVALID_CERTIFICATES_HINT, Qt::ToolTipRole);
+        _authMethodComboBox->setItemData(1, CA_FILE_HINT, Qt::ToolTipRole);
+        _selfSignedInfoStr = new QLabel("In general, avoid using self-signed certificates unless the network is trusted. "
+            "If self-signed certificate is used, the communications channel will be encrypted however there will be "
+            "no validation of server identity.");
+        _selfSignedInfoStr->setWordWrap(true);
+        _selfSignedInfoStr->setToolTip(ALLOW_INVALID_CERTIFICATES_HINT);
+        _caFileLabel = new QLabel("CA Certificate:");
+        _caFileLabel->setToolTip(CA_FILE_HINT);
+        _caFilePathLineEdit = new QLineEdit;
+        _caFileBrowseButton = new QPushButton("...");
+        _caFileBrowseButton->setMaximumWidth(50);
+        VERIFY(connect(_caFileBrowseButton, SIGNAL(clicked()), this, SLOT(on_caFileBrowseButton_clicked())));
+        VERIFY(connect(_authMethodComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(on_authModeComboBox_change(int))));
+
+        // PEM file section
+        _usePemFileCheckBox = new QCheckBox("Use PEM Cert./Key: ");
+        _usePemFileCheckBox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+        _pemFileInfoStr = 
+            new QLabel("Enable this option to connect to a MongoDB that requires CA-signed client certificates/key file.");
+        _pemFileInfoStr->setWordWrap(true);
+#ifdef Q_OS_WIN
+        _pemFileInfoStr->setContentsMargins(0,2,0,0);   // Top alignment adjustment required only for Windows
+#endif
+        _pemFileLabel = new QLabel("PEM Certificate/Key: ");
+        _pemFileLabel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
+        _pemFileLabel->setToolTip(PEM_FILE_HINT);
+        _pemFilePathLineEdit = new QLineEdit;
+        _pemFileBrowseButton = new QPushButton("...");
+        _pemFileBrowseButton->setMaximumWidth(50);
+        VERIFY(connect(_usePemFileCheckBox, SIGNAL(toggled(bool)), this, SLOT(on_usePemFileCheckBox_toggle(bool))));
+        VERIFY(connect(_pemFileBrowseButton, SIGNAL(clicked()), this, SLOT(on_pemKeyFileBrowseButton_clicked())));
+        // PEM Passphrase section
+        _pemPassLabel = new QLabel("Passphrase: ");    
+        _pemPassLabel->setToolTip(PEM_PASS_HINT);
+        _pemPassLineEdit = new QLineEdit;
+        _pemPassShowButton = new QPushButton;
+        // Fix for MAC OSX: PEM pass show button was created bigger, making it same size as other pushbuttons
+        _pemPassShowButton->setMaximumWidth(_pemFileBrowseButton->width());
+        VERIFY(connect(_pemPassShowButton, SIGNAL(clicked()), this, SLOT(togglePassphraseShowMode())));
+        togglePassphraseShowMode();
+        _askPemPassCheckBox = new QCheckBox("Ask for passphrase each time");
+        _askPemPassCheckBox->setChecked(sslSettings->askPassphrase());
+        VERIFY(connect(_askPemPassCheckBox, SIGNAL(toggled(bool)), this, SLOT(on_askPemPassCheckBox_toggle(bool))));
+
+        // Advanced options
+        _useAdvancedOptionsCheckBox = new QCheckBox("Advanced Options");
+        _useAdvancedOptionsCheckBox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
+        VERIFY(connect(_useAdvancedOptionsCheckBox, SIGNAL(toggled(bool)), this, SLOT(on_useAdvancedOptionsCheckBox_toggle(bool))));
+        _crlFileLabel = new QLabel("CRL (Revocation List): ");
+        _crlFileLabel->setToolTip(CRL_FILE_HINT);
+        _crlFilePathLineEdit = new QLineEdit;
+        _crlFileBrowseButton = new QPushButton("...");
+        _crlFileBrowseButton->setMaximumWidth(50);
+        VERIFY(connect(_crlFileBrowseButton, SIGNAL(clicked()), this, SLOT(on_crlFileBrowseButton_clicked())));
+        _allowInvalidHostnamesLabel = new QLabel("Invalid Hostnames: ");
+        _allowInvalidHostnamesLabel->setToolTip(ALLOW_INVALID_HOSTNAME_HINT);
+        _allowInvalidHostnamesComboBox = new QComboBox;
+        _allowInvalidHostnamesComboBox->addItem("Not Allowed");
+        _allowInvalidHostnamesComboBox->addItem("Allowed");
+        _allowInvalidHostnamesComboBox->setCurrentIndex(sslSettings->allowInvalidHostnames());
+
+        // Layouts
+        // Auth. method section
+        QGridLayout* gridLayout = new QGridLayout;
+        gridLayout->addWidget(_authMethodLabel,                 0 ,0);
+        gridLayout->addWidget(_authMethodComboBox,              0 ,1, 1, 2);
+        gridLayout->addWidget(_selfSignedInfoStr,               1, 1, 1, 2);
+        gridLayout->addWidget(_caFileLabel,                     2, 0);
+        gridLayout->addWidget(_caFilePathLineEdit,              2, 1);
+        gridLayout->addWidget(_caFileBrowseButton,              2, 2);        
+        gridLayout->addWidget(new QLabel(""),                   3, 0);        
+        // PEM File Section
+        gridLayout->addWidget(_usePemFileCheckBox,              4, 0, Qt::AlignTop);
+        gridLayout->addWidget(_pemFileInfoStr,                  4, 1, 1, 2);
+        gridLayout->addWidget(_pemFileLabel,                    5, 0);
+        gridLayout->addWidget(_pemFilePathLineEdit,             5, 1);
+        gridLayout->addWidget(_pemFileBrowseButton,             5, 2);
+        gridLayout->addWidget(_pemPassLabel,                    6, 0);
+        gridLayout->addWidget(_pemPassLineEdit,                 6, 1);
+        gridLayout->addWidget(_pemPassShowButton,               6, 2);
+        gridLayout->addWidget(_askPemPassCheckBox,              7, 1, 1, 2);
+        gridLayout->addWidget(new QLabel(""),                   8, 0);        
+        // Advanced section
+        gridLayout->addWidget(_useAdvancedOptionsCheckBox,      9, 0, Qt::AlignTop);
+        gridLayout->addWidget(_crlFileLabel,                    10, 0);
+        gridLayout->addWidget(_crlFilePathLineEdit,             10, 1);
+        gridLayout->addWidget(_crlFileBrowseButton,             10, 2);
+        gridLayout->addWidget(_allowInvalidHostnamesLabel,      11, 0);
+        gridLayout->addWidget(_allowInvalidHostnamesComboBox,   11, 1, Qt::AlignLeft);
+        gridLayout->addWidget(new QLabel(""),                   12, 0);   
+
+        QLabel* spacingAfterFirstRow = new QLabel("");
+        spacingAfterFirstRow->setFixedHeight(5);
+
+        QVBoxLayout *mainLayout = new QVBoxLayout;
+        mainLayout->setAlignment(Qt::AlignTop);
+        mainLayout->addWidget(_useSslCheckBox);
+        mainLayout->addWidget(spacingAfterFirstRow);
+        mainLayout->addLayout(gridLayout);
+        setLayout(mainLayout);
+
+        // Load SSL settings to update UI states
+        _useSslCheckBox->setChecked(sslSettings->sslEnabled());
+        _authMethodComboBox->setCurrentIndex(!sslSettings->allowInvalidCertificates());
+        _caFilePathLineEdit->setText(QString::fromStdString(sslSettings->caFile()));
+        _usePemFileCheckBox->setChecked(sslSettings->usePemFile());
+        _pemFilePathLineEdit->setText(QString::fromStdString(sslSettings->pemKeyFile()));
+        _askPemPassCheckBox->setChecked(sslSettings->askPassphrase());
+        // Load passphrase only if askPassphrase is false
+        if (!sslSettings->askPassphrase())
+        {
+            _pemPassLineEdit->setText(QString::fromStdString(sslSettings->pemPassPhrase()));
+        }
+        _useAdvancedOptionsCheckBox->setChecked(sslSettings->useAdvancedOptions());
+        _allowInvalidHostnamesComboBox->setCurrentIndex(sslSettings->allowInvalidHostnames());
+        _crlFilePathLineEdit->setText(QString::fromStdString(sslSettings->crlFile()));
+
+        // Update UI inter-connected (signal-slot) widget states
+        on_authModeComboBox_change(_authMethodComboBox->currentIndex());
+        on_usePemFileCheckBox_toggle(_usePemFileCheckBox->isChecked());
+        on_askPemPassCheckBox_toggle(_askPemPassCheckBox->isChecked());
+        on_useAdvancedOptionsCheckBox_toggle(_useAdvancedOptionsCheckBox->isChecked());
+
+        // Enable/disable all SSL tab widgets
+        useSslCheckBoxStateChange(_useSslCheckBox->checkState());
+
+        // Attempt to fix issue for Windows High DPI button height is slightly taller than other widgets 
+#ifdef Q_OS_WIN
+        _caFileBrowseButton->setMaximumHeight(HighDpiContants::WIN_HIGH_DPI_BUTTON_HEIGHT);
+        _pemFileBrowseButton->setMaximumHeight(HighDpiContants::WIN_HIGH_DPI_BUTTON_HEIGHT);
+        _pemPassShowButton->setMaximumHeight(HighDpiContants::WIN_HIGH_DPI_BUTTON_HEIGHT);
+        _crlFileBrowseButton->setMaximumHeight(HighDpiContants::WIN_HIGH_DPI_BUTTON_HEIGHT);
+#endif
+
+    }
+
+    bool SSLTab::accept()
+    {
+        saveSslSettings();
+        return validate();
+    }
+
+    bool SSLTab::sslEnabled() const 
+    { 
+        return _useSslCheckBox->isChecked(); 
+    }
+
+    void SSLTab::useSslCheckBoxStateChange(int state)
+    {
+        bool isChecked = static_cast<bool>(state);
+        _authMethodLabel->setDisabled(!isChecked);
+        _authMethodComboBox->setDisabled(!isChecked);
+        _selfSignedInfoStr->setDisabled(!isChecked);
+        _caFileLabel->setDisabled(!isChecked);
+        _caFilePathLineEdit->setDisabled(!isChecked);
+        _caFileBrowseButton->setDisabled(!isChecked);
+        _usePemFileCheckBox->setDisabled(!isChecked);
+        _pemFileInfoStr->setDisabled(!isChecked);
+        _pemFileLabel->setDisabled(!isChecked);
+        _pemFilePathLineEdit->setDisabled(!isChecked);
+        _pemFileBrowseButton->setDisabled(!isChecked);
+        _pemPassLabel->setDisabled(!isChecked);
+        _pemPassLineEdit->setDisabled(!isChecked);
+        _pemPassShowButton->setDisabled(!isChecked);
+        _askPemPassCheckBox->setDisabled(!isChecked);
+        _useAdvancedOptionsCheckBox->setDisabled(!isChecked);
+        _crlFileLabel->setDisabled(!isChecked);
+        _crlFilePathLineEdit->setDisabled(!isChecked);
+        _crlFileBrowseButton->setDisabled(!isChecked);
+        _allowInvalidHostnamesLabel->setDisabled(!isChecked);
+        _allowInvalidHostnamesComboBox->setDisabled(!isChecked);
+        if (isChecked)  // Update some widgets only if SSL enabled
+        {
+            on_usePemFileCheckBox_toggle(_usePemFileCheckBox->isChecked());
+            on_askPemPassCheckBox_toggle(_askPemPassCheckBox->isChecked());
+        }
+    }
+
+    void SSLTab::on_authModeComboBox_change(int index)
+    {
+        bool const isCaSigned = static_cast<bool>(index);
+        _selfSignedInfoStr->setVisible(!isCaSigned);
+        _caFileLabel->setVisible(isCaSigned);
+        _caFilePathLineEdit->setVisible(isCaSigned);
+        _caFileBrowseButton->setVisible(isCaSigned);
+        if (!isCaSigned)
+        {
+            setMinimumHeight(330);
+        }
+    }
+
+    void SSLTab::on_usePemFileCheckBox_toggle(bool isChecked)
+    {
+        _pemFileInfoStr->setVisible(!isChecked);
+        _pemFileLabel->setVisible(isChecked);
+        _pemFilePathLineEdit->setVisible(isChecked);
+        _pemFileBrowseButton->setVisible(isChecked);
+        _pemPassLabel->setVisible(isChecked);
+        _pemPassLineEdit->setVisible(isChecked);
+        _pemPassShowButton->setVisible(isChecked);
+        _askPemPassCheckBox->setVisible(isChecked);
+        if(isChecked)
+        {
+            setMinimumHeight(440);
+        }
+    }
+
+    void SSLTab::on_useAdvancedOptionsCheckBox_toggle(bool isChecked)
+    {
+        _crlFileLabel->setVisible(isChecked);
+        _crlFilePathLineEdit->setVisible(isChecked);
+        _crlFileBrowseButton->setVisible(isChecked);
+        _allowInvalidHostnamesLabel->setVisible(isChecked);
+        _allowInvalidHostnamesComboBox->setVisible(isChecked);
+        if(isChecked)
+        {
+            setMinimumHeight(500);
+        }
+    }
+
+    void SSLTab::on_caFileBrowseButton_clicked()
+    {
+        QString const& fileName = openFileBrowseDialog(_caFilePathLineEdit->text());
+        if (!fileName.isEmpty()) {
+            _caFilePathLineEdit->setText(fileName);
+        }
+    }
+
+    void SSLTab::on_pemKeyFileBrowseButton_clicked()
+    {
+        QString const& fileName = openFileBrowseDialog(_pemFilePathLineEdit->text());
+        if (!fileName.isEmpty()) {
+            _pemFilePathLineEdit->setText(fileName);
+        }
+    }
+
+    void SSLTab::on_crlFileBrowseButton_clicked()
+    {
+        QString const& fileName = openFileBrowseDialog(_crlFilePathLineEdit->text());
+        if (!fileName.isEmpty()) {
+            _crlFilePathLineEdit->setText(fileName);
+        }
+    }
+
+    void SSLTab::togglePassphraseShowMode()
+    {
+        bool isPassword = _pemPassLineEdit->echoMode() == QLineEdit::Password;
+        _pemPassLineEdit->setEchoMode(isPassword ? QLineEdit::Normal : QLineEdit::Password);
+        _pemPassShowButton->setIcon(isPassword ? GuiRegistry::instance().showIcon() : GuiRegistry::instance().hideIcon());
+    }
+
+    void SSLTab::on_askPemPassCheckBox_toggle(bool checked)
+    {
+        //if (_usePemFileCheckBox->isChecked())
+        //{
+            _pemPassLabel->setDisabled(checked);
+            _pemPassLineEdit->setDisabled(checked);
+            _pemPassShowButton->setDisabled(checked);
+            if (checked)
+            {
+                _pemPassLineEdit->setText("");  // clear passphrase on UI
+            }
+        //}
+    }
+
+    bool SSLTab::validate()
+    {
+        // Validate existence of files
+        auto const& resultAndFileName = checkExistenseOfFiles();
+        if (!resultAndFileName.first)
+        {
+            QString const& nonExistingFile = resultAndFileName.second;
+            QMessageBox errorBox;
+            errorBox.critical(this, "Error", ("Error: " + nonExistingFile + " file does not exist"));
+            errorBox.adjustSize();
+            return false;
+        }
+
+        return true;
+    }
+
+    std::pair<bool,QString> SSLTab::checkExistenseOfFiles() const
+    {
+        if (_caFilePathLineEdit->isEnabled() && _caFilePathLineEdit->isVisible()) {
+            if (!fileExists(_caFilePathLineEdit->text())) {
+                return {false, "CA-signed certificate"};
+            }
+        }
+
+        if (_pemFilePathLineEdit->isVisible() && _pemFilePathLineEdit->isEnabled()) {
+            if (!fileExists(_pemFilePathLineEdit->text())) {
+                return {false, "PEM Certificate/Key"};
+            }
+        }
+
+        if (!_crlFilePathLineEdit->text().isEmpty()) {
+            if (!fileExists(_crlFilePathLineEdit->text())) {
+                return {false, "CRL (Revocation List)"};
+            }
+        }
+        return {true, ""};
+    }
+
+    void SSLTab::saveSslSettings() const
+    {
+        SslSettings* sslSettings = _connSettings->sslSettings();
+        sslSettings->enableSSL(_useSslCheckBox->isChecked());
+        sslSettings->setAllowInvalidCertificates(!static_cast<bool>(_authMethodComboBox->currentIndex()));
+        sslSettings->setCaFile(QtUtils::toStdString(_caFilePathLineEdit->text()));
+        sslSettings->setUsePemFile(_usePemFileCheckBox->isChecked());
+        sslSettings->setPemKeyFile(QtUtils::toStdString(_pemFilePathLineEdit->text()));
+        sslSettings->setAskPassphrase(_askPemPassCheckBox->isChecked());
+        // save passphrase only if _askPemPassCheckBox is not checked; otherwise don't save and clear saved passphrase
+        if (!_askPemPassCheckBox->isChecked())
+        {
+            sslSettings->setPemPassPhrase(QtUtils::toStdString(_pemPassLineEdit->text()));
+        }
+        else
+        {
+            sslSettings->setPemPassPhrase("");
+        }
+        sslSettings->setUseAdvancedOptions(_useAdvancedOptionsCheckBox->isChecked());
+        sslSettings->setCrlFile(QtUtils::toStdString(_crlFilePathLineEdit->text()));
+        sslSettings->setAllowInvalidHostnames(static_cast<bool>(_allowInvalidHostnamesComboBox->currentIndex()));
+    }
+
+    QString SSLTab::openFileBrowseDialog(const QString& initialPath)
+    {
+        QString filePath = initialPath;
+        // If user has previously selected a file, initialize file dialog with that file's 
+        // path and name; otherwise, use user's home directory.
+        if (filePath.isEmpty())
+        {
+            filePath = QDir::homePath();
+        }
+        QString fileName = QFileDialog::getOpenFileName(this, tr("Choose File"), filePath);
+
+        // Some strange behaviour at least on Mac happens when you close QFileDialog. Focus switched to a different modal
+        // dialog, not the one that was active before openning QFileDialog.
+        // http://stackoverflow.com/questions/17998811/window-modal-qfiledialog-pushing-parent-to-background-after-exec
+        QApplication::activeModalWidget()->raise();
+        QApplication::activeModalWidget()->activateWindow();
+
+        return QDir::toNativeSeparators(fileName);
+    }
+}
+

src/robomongo/gui/dialogs/SSLTab.h

@@ -0,0 +1,151 @@
+#pragma once
+
+#include <QWidget>
+
+#include "robomongo/core/settings/ConnectionSettings.h"
+
+QT_BEGIN_NAMESPACE
+class QLabel;
+class QLineEdit;
+class QCheckBox;
+class QPushButton;
+class QRadioButton;
+class QComboBox;
+QT_END_NAMESPACE
+
+namespace Robomongo
+{
+    class ConnectionSettings;
+
+    class SSLTab : public QWidget
+    {
+        Q_OBJECT
+
+    public:
+        /**
+        * @brief Construct SSL tab of ConnectionDialog
+        * @param settings: Pointer to active connection's ConnectionsSettings member
+        */
+        SSLTab(ConnectionSettings *settings);
+        
+        /**
+        * @brief  Save dialog input into connection's ssl settings
+        * @return true on success, false otherwise
+        */
+        bool accept();
+
+        /**
+        * @return true if use SSL checkbox is checked, false otherwise
+        */
+        bool sslEnabled() const;
+
+    private Q_SLOTS :
+        
+        /**
+        * @brief Disable/enable widgets according to SSL check box state
+        */ 
+        void useSslCheckBoxStateChange(int checked);
+        
+        /**
+        * @brief Disable/enable widgets according to state of authentication method combo box
+        */
+        void on_authModeComboBox_change(int index);
+
+        /**
+        * @brief Disable/enable widgets according to state of use PEM file combo box
+        */
+        void on_usePemFileCheckBox_toggle(bool checked);
+
+        /**
+        * @brief Disable/enable widgets according to state of advanced options combo box
+        */
+        void on_useAdvancedOptionsCheckBox_toggle(bool checked);
+        
+        /**
+        * @brief File browsers for SSL related cert/key files
+        */
+        void on_caFileBrowseButton_clicked();
+        void on_pemKeyFileBrowseButton_clicked();
+        void on_crlFileBrowseButton_clicked();
+        
+        /**
+        * @brief Show/hide client cert's passphrase on Show/Hide button pressed
+        */
+        void togglePassphraseShowMode();
+
+        /**
+        * @brief Enable/disable/clean PEM passphrase widgets section
+        */
+        void on_askPemPassCheckBox_toggle(bool checked);
+
+    private:
+
+        /**
+        * @brief Do validation according to user input in UI
+        * @return true on success, false otherwise
+        */
+        bool validate();
+
+        /**
+        * @brief  Check existence of files: CA cert, Client Cert and CRL file
+        * @return true if all files exist, false any of them does not exist
+        * @return QString Lable of file which does not exist, empty string if all files exist
+        */
+        std::pair<bool, QString> checkExistenseOfFiles() const;
+
+        /**
+        * @brief Save dialog input into connection's ssl settings
+        */
+        void saveSslSettings() const;
+
+        /**
+        * @brief 
+        * @param initialPath Previously selected file path
+        * @return Selected file absolute path and file name
+        */
+        QString openFileBrowseDialog(const QString& initialPath);
+
+        /**
+        * @brief Main checkbox to disable/enable all other SSL tab widgets
+        */
+        QCheckBox *_useSslCheckBox;
+        
+        /**
+        * @brief Auth. Method widgets
+        */
+        QLabel *_authMethodLabel;
+        QComboBox *_authMethodComboBox;
+        QLabel *_selfSignedInfoStr;
+        QLabel *_caFileLabel;
+        QLineEdit *_caFilePathLineEdit;
+        QPushButton *_caFileBrowseButton;
+
+        /**
+        * @brief PEM file widgets
+        */
+        QCheckBox* _usePemFileCheckBox;
+        QLabel* _pemFileInfoStr;
+        QLabel* _pemFileLabel;
+        QLineEdit *_pemFilePathLineEdit;
+        QPushButton *_pemFileBrowseButton;
+        QLabel* _pemPassLabel;
+        QLineEdit* _pemPassLineEdit;
+        QPushButton* _pemPassShowButton;
+        QCheckBox* _askPemPassCheckBox;
+
+        /**
+        * @brief Advanced options widgets
+        */
+        QCheckBox* _useAdvancedOptionsCheckBox;
+        QLabel *_crlFileLabel;
+        QLineEdit *_crlFilePathLineEdit;
+        QPushButton *_crlFileBrowseButton;
+        QLabel *_allowInvalidHostnamesLabel;
+        QComboBox *_allowInvalidHostnamesComboBox;
+
+        /**
+        * @brief Pointer to active connection's settings
+        */
+        ConnectionSettings *const _connSettings;
+    };
+} /* end of Robomongo namespace */

src/robomongo/gui/editors/FindFrame.cpp

@@ -33,12 +33,13 @@ namespace Robomongo
         _close->setIcon(QIcon(":/robomongo/icons/close_2_16x16.png"));
         _close->setToolButtonStyle(Qt::ToolButtonIconOnly);
         _close->setIconSize(QSize(16, 16));
+        _close->hide(); // We do not need close button because ESC works
+
         _findLine->setAlignment(Qt::AlignLeft | Qt::AlignAbsolute);
 
         QHBoxLayout *layout = new QHBoxLayout();
-        layout->setContentsMargins(6, 0, 6, 0);
-        layout->setSpacing(4);
-        layout->addWidget(_close);
+        layout->setContentsMargins(2, 0, 6, 0);
+        layout->setSpacing(7);
         layout->addWidget(_findLine);
         layout->addWidget(_next);
         layout->addWidget(_prev);
@@ -50,8 +51,8 @@ namespace Robomongo
         QVBoxLayout *mainLayout = new QVBoxLayout();
         mainLayout->setContentsMargins(0, 0, 0, 0);
         mainLayout->setSpacing(0);
-        mainLayout->addWidget(_scin);
-        mainLayout->addWidget(_findPanel);
+        mainLayout->addWidget(_scin, 1);
+        mainLayout->addWidget(_findPanel, 0, Qt::AlignBottom);
         setLayout(mainLayout);
 
         _findPanel->hide();
@@ -71,14 +72,17 @@ namespace Robomongo
         bool isFocusScin = _scin->isActiveWindow();
         bool isShowFind = _findPanel->isVisible();
         if (Qt::Key_Escape == keyEvent->key() && isFocusScin && isShowFind) {
+            // Hide & Show of Scintilla widget solves problem of UI blinking
+            _scin->hide();
             _findPanel->hide();
             _scin->setFocus();
+            _scin->show();
             return keyEvent->accept();
         } else if (Qt::Key_Return == keyEvent->key() && (keyEvent->modifiers() & Qt::ShiftModifier) && isFocusScin && isShowFind) {
             goToPrevElement();
         } else if (Qt::Key_Return == keyEvent->key() && isFocusScin && isShowFind) {
             goToNextElement();
-        } else if (((keyEvent->modifiers() & Qt::ControlModifier) && keyEvent->key()==Qt::Key_F) && isFocusScin) {
+        } else if (((keyEvent->modifiers() & Qt::ControlModifier) && keyEvent->key() == Qt::Key_F) && isFocusScin) {
             _findPanel->show();
             _findLine->setFocus();
             _findLine->selectAll();
@@ -122,7 +126,7 @@ namespace Robomongo
                 _scin->ensureCursorVisible(); 
             }
             else {
-                QMessageBox::warning(this, tr("Search"),tr("The specified text was not found."));
+                QMessageBox::warning(this, tr("Search"), tr("The specified text was not found."));
             }            
         }
     }

src/robomongo/gui/editors/FindFrame.h

@@ -21,7 +21,7 @@ namespace Robomongo
     public:
         enum
         {
-            HeightFindPanel = 40
+            HeightFindPanel = 38
         };
         typedef QFrame BaseClass;
         explicit FindFrame(QWidget *parent);

src/robomongo/gui/editors/PlainJavaScriptEditor.cpp

@@ -155,13 +155,13 @@ namespace Robomongo
         }
 
         if (((keyEvent->modifiers() & Qt::ControlModifier) &&
-            (keyEvent->key()==Qt::Key_F4 || keyEvent->key()==Qt::Key_W ||
-             keyEvent->key()==Qt::Key_T || keyEvent->key()==Qt::Key_Space ||
-             keyEvent->key()==Qt::Key_F || keyEvent->key()==Qt::Key_Slash))
+            (keyEvent->key() == Qt::Key_F4 || keyEvent->key() == Qt::Key_W ||
+             keyEvent->key() == Qt::Key_T || keyEvent->key() == Qt::Key_Space ||
+             keyEvent->key() == Qt::Key_F || keyEvent->key() == Qt::Key_Slash))
             || keyEvent->key() == Qt::Key_Escape /*|| keyEvent->key() == Qt::Key_Return*/
-            || ((keyEvent->modifiers() & Qt::ControlModifier) && (keyEvent->modifiers() & Qt::AltModifier) && keyEvent->key()==Qt::Key_Left)
-            || ((keyEvent->modifiers() & Qt::ControlModifier) && (keyEvent->modifiers() & Qt::AltModifier) && keyEvent->key()==Qt::Key_Right)
-            || ((keyEvent->modifiers() & Qt::ControlModifier) && (keyEvent->modifiers() & Qt::ShiftModifier) && keyEvent->key()==Qt::Key_C)
+            || ((keyEvent->modifiers() & Qt::ControlModifier) && (keyEvent->modifiers() & Qt::AltModifier) && keyEvent->key() == Qt::Key_Left)
+            || ((keyEvent->modifiers() & Qt::ControlModifier) && (keyEvent->modifiers() & Qt::AltModifier) && keyEvent->key() == Qt::Key_Right)
+            || ((keyEvent->modifiers() & Qt::ControlModifier) && (keyEvent->modifiers() & Qt::ShiftModifier) && keyEvent->key() == Qt::Key_C)
            )
         {
             keyEvent->ignore();
@@ -182,4 +182,18 @@ namespace Robomongo
             setMarginWidth(0, _lineNumberMarginWidth);
         }
     }
+
+    void RoboScintilla::setAppropriateBraceMatching() {
+#ifdef Q_OS_MAC
+        // On Mac OS when brace matching is enabled, text
+        // will blink when you move cursor to some brace or
+        // when inside braces. This behaviour is not fully fixed
+        // in QScintilla 2.9.1 and 2.8.4
+        setBraceMatching(QsciScintilla::NoBraceMatch);
+#else
+        setBraceMatching(QsciScintilla::StrictBraceMatch);
+#endif
+    }
+
+
 }

src/robomongo/gui/editors/PlainJavaScriptEditor.h

@@ -19,6 +19,7 @@ namespace Robomongo
         void setIgnoreTabKey(bool ignore) { _ignoreTabKey = ignore; }
         int lineNumberMarginWidth() const;
         int textWidth(int style, const QString &text);
+        void setAppropriateBraceMatching();
 
     protected:
         void wheelEvent(QWheelEvent *e);

src/robomongo/gui/resources/gui.qrc

@@ -16,8 +16,14 @@
         <file>icons/bson_object_16x16.png</file>
         <file>icons/database_16x16.png</file>
         <file>icons/loading.gif</file>
+        <file>icons/loading_ticks_40x40.gif</file>
         <file>scripts/esprima.js</file>
+        <file>scripts/uuidhelpers.js</file>
         <file>icons/maximize.gif</file>
+        <file>icons/undock.png</file>
+        <file>icons/dock.png</file>
+        <file>icons/maximize.png</file>
+        <file>icons/minimize.png</file>
         <file>icons/text_16x16.png</file>
         <file>icons/tree_16x16.png</file>
         <file>icons/rotate_16x16.png</file>
@@ -28,6 +34,8 @@
         <file>icons/mongodb_16x16.png</file>
         <file>icons/connect_24x24.png</file>
         <file>icons/server_16x16.png</file>
+        <file>icons/server_imported_16x16.png</file>
+        <file>icons/replica_set_16x16.png</file>
         <file>icons/execute_24x24.png</file>
         <file>icons/main_window_icon_old.png</file>
         <file>icons/logo-256x256.png</file>
@@ -38,8 +46,14 @@
         <file>icons/maximize_highlighted_16x16.png</file>
         <file>icons/table_16x16.png</file>
         <file>icons/table_highlighted_16x16.png</file>
-        <file>icons/no_mark_16x16.png</file>
-        <file>icons/yes_mark_16x16.png</file>
+        <file>icons/no_mark_24x24.png</file>
+        <file>icons/no_mark_24x24@2x.png</file>
+        <file>icons/yes_mark_24x24.png</file>
+        <file>icons/yes_mark_24x24@2x.png</file>
+        <file>icons/skip_mark_24x24.png</file>
+        <file>icons/skip_mark_24x24@2x.png</file>
+        <file>icons/question_mark_24x24.png</file>
+        <file>icons/question_mark_24x24@2x.png</file>
         <file>icons/time_16x16.png</file>
         <file>icons/key_16x16.png</file>
         <file>icons/progress_bar.gif</file>
@@ -50,5 +64,7 @@
         <file>icons/stop_24x24.png</file>
         <file>icons/function_16x16.png</file>
         <file>icons/index_16x16.png</file>
+        <file>icons/hide_64x64.png</file>
+        <file>icons/show_64x64.png</file>
     </qresource>
 </RCC>