src/screen.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2014 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include <cassert>
  22
  23 #include "global.h"
  24 #include "screen.h"
  25 #include "settings.h"
  26
  27 using Global::myScreen;
  28 using Global::myLockedScreen;
  29 using Global::myInactiveScreen;
  30
  31 void drawSeparator(int x)
  32 {
  33         color_set(Config.main_color.pairNumber(), nullptr);
  34         mvvline(Global::MainStartY, x, 0, Global::MainHeight);
  35         standend();
  36         refresh();
  37 }
  38
  39 void genericMouseButtonPressed(NC::Window &w, MEVENT me)
  40 {
  41         if (me.bstate & BUTTON5_PRESSED)
  42         {
  43                 if (Config.mouse_list_scroll_whole_page)
  44                         w.scroll(NC::Scroll::PageDown);
  45                 else
  46                         for (size_t i = 0; i < Config.lines_scrolled; ++i)
  47                                 w.scroll(NC::Scroll::Down);
  48         }
  49         else if (me.bstate & BUTTON4_PRESSED)
  50         {
  51                 if (Config.mouse_list_scroll_whole_page)
  52                         w.scroll(NC::Scroll::PageUp);
  53                 else
  54                         for (size_t i = 0; i < Config.lines_scrolled; ++i)
  55                                 w.scroll(NC::Scroll::Up);
  56         }
  57 }
  58
  59 void scrollpadMouseButtonPressed(NC::Scrollpad &w, MEVENT me)
  60 {
  61         if (me.bstate & BUTTON5_PRESSED)
  62         {
  63                 for (size_t i = 0; i < Config.lines_scrolled; ++i)
  64                         w.scroll(NC::Scroll::Down);
  65         }
  66         else if (me.bstate & BUTTON4_PRESSED)
  67         {
  68                 for (size_t i = 0; i < Config.lines_scrolled; ++i)
  69                         w.scroll(NC::Scroll::Up);
  70         }
  71 }
  72
  73 /***********************************************************************/
  74
  75 void BaseScreen::getWindowResizeParams(size_t &x_offset, size_t &width, bool adjust_locked_screen)
  76 {
  77         width = COLS;
  78         x_offset = 0;
  79         if (myLockedScreen && myInactiveScreen)
  80         {
  81                 size_t locked_width = COLS*Config.locked_screen_width_part;
  82                 if (myLockedScreen == this)
  83                         width = locked_width;
  84                 else
  85                 {
  86                         width = COLS-locked_width-1;
  87                         x_offset = locked_width+1;
  88
  89                         if (adjust_locked_screen)
  90                         {
  91                                 myLockedScreen->resize();
  92                                 myLockedScreen->refresh();
  93                                 drawSeparator(x_offset-1);
  94                         }
  95                 }
  96         }
  97 }
  98
  99 bool BaseScreen::lock()
 100 {
 101         assert(myLockedScreen == nullptr);
 102         if (isLockable())
 103         {
 104                 myLockedScreen = this;
 105                 return true;
 106         }
 107         else
 108                 return false;
 109 }
 110
 111 void BaseScreen::unlock()
 112 {
 113         if (myInactiveScreen && myInactiveScreen != myLockedScreen)
 114                 myScreen = myInactiveScreen;
 115         if (myScreen != myLockedScreen)
 116                 myLockedScreen->switchTo();
 117         myLockedScreen = 0;
 118         myInactiveScreen = 0;
 119 }
 120
 121 /***********************************************************************/
 122
 123 void applyToVisibleWindows(std::function<void(BaseScreen *)> f)
 124 {
 125         if (myLockedScreen && myScreen->isMergable())
 126         {
 127                 if (myScreen == myLockedScreen)
 128                 {
 129                         if (myInactiveScreen)
 130                                 f(myInactiveScreen);
 131                 }
 132                 else
 133                         f(myLockedScreen);
 134         }
 135         f(myScreen);
 136 }
 137
 138 void updateInactiveScreen(BaseScreen *screen_to_be_set)
 139 {
 140         if (myInactiveScreen && myLockedScreen != myInactiveScreen && myLockedScreen == screen_to_be_set)
 141         {
 142                 // if we're here, the following conditions are (or at least should be) met:
 143                 // 1. screen is split (myInactiveScreen is not null)
 144                 // 2. current screen (myScreen) is not splittable, ie. is stacked on top of split screens
 145                 // 3. current screen was activated while master screen was active
 146                 // 4. we are returning to master screen
 147                 // in such case we want to keep slave screen visible, so we never set it to null
 148                 // as in "else" case. we also need to refresh it and redraw separator between
 149                 // them as stacked screen probably has overwritten part ot it.
 150                 myInactiveScreen->refresh();
 151                 drawSeparator(COLS*Config.locked_screen_width_part);
 152         }
 153         else
 154         {
 155                 if (myLockedScreen == screen_to_be_set)
 156                         myInactiveScreen = 0;
 157                 else
 158                         myInactiveScreen = myLockedScreen;
 159         }
 160 }
 161
 162 bool isVisible(BaseScreen *screen)
 163 {
 164         assert(screen != 0);
 165         if (myLockedScreen && myScreen->isMergable())
 166                 return screen == myScreen || screen == myInactiveScreen || screen == myLockedScreen;
 167         else
 168                 return screen == myScreen;
 169 }