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         attron(COLOR_PAIR(int(Config.main_color)));
  34         mvvline(Global::MainStartY, x, 0, Global::MainHeight);
  35         attroff(COLOR_PAIR(int(Config.main_color)));
  36         refresh();
  37 }
  38
  39 void genericMouseButtonPressed(NC::Window &w, MEVENT me)
  40 {
  41         if (me.bstate & BUTTON2_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 & BUTTON2_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         if (myLockedScreen)
 102                 return false;
 103         if (isLockable())
 104         {
 105                 myLockedScreen = this;
 106                 return true;
 107         }
 108         else
 109                 return false;
 110 }
 111
 112 void BaseScreen::unlock()
 113 {
 114         if (myInactiveScreen && myInactiveScreen != myLockedScreen)
 115                 myScreen = myInactiveScreen;
 116         if (myScreen != myLockedScreen)
 117                 myLockedScreen->switchTo();
 118         myLockedScreen = 0;
 119         myInactiveScreen = 0;
 120 }
 121
 122 /***********************************************************************/
 123
 124 void applyToVisibleWindows(std::function<void(BaseScreen *)> f)
 125 {
 126         if (myLockedScreen && myScreen->isMergable())
 127         {
 128                 if (myScreen == myLockedScreen)
 129                 {
 130                         if (myInactiveScreen)
 131                                 f(myInactiveScreen);
 132                 }
 133                 else
 134                         f(myLockedScreen);
 135         }
 136         f(myScreen);
 137 }
 138
 139 void updateInactiveScreen(BaseScreen *screen_to_be_set)
 140 {
 141         if (myInactiveScreen && myLockedScreen != myInactiveScreen && myLockedScreen == screen_to_be_set)
 142         {
 143                 // if we're here, the following conditions are (or at least should be) met:
 144                 // 1. screen is split (myInactiveScreen is not null)
 145                 // 2. current screen (myScreen) is not splittable, ie. is stacked on top of split screens
 146                 // 3. current screen was activated while master screen was active
 147                 // 4. we are returning to master screen
 148                 // in such case we want to keep slave screen visible, so we never set it to null
 149                 // as in "else" case. we also need to refresh it and redraw separator between
 150                 // them as stacked screen probably has overwritten part ot it.
 151                 myInactiveScreen->refresh();
 152                 drawSeparator(COLS*Config.locked_screen_width_part);
 153         }
 154         else
 155         {
 156                 if (myLockedScreen == screen_to_be_set)
 157                         myInactiveScreen = 0;
 158                 else
 159                         myInactiveScreen = myLockedScreen;
 160         }
 161 }
 162
 163 bool isVisible(BaseScreen *screen)
 164 {
 165         assert(screen != 0);
 166         if (myLockedScreen && myScreen->isMergable())
 167                 return screen == myScreen || screen == myInactiveScreen || screen == myLockedScreen;
 168         else
 169                 return screen == myScreen;
 170 }