git.mutantstargoat.com Git - winnie/blob - src/wm.cc

   1 #include <algorithm>
   2 #include <stdexcept>
   3 #include <stdio.h>      // TODO
   4
   5 #include "gfx.h"
   6 #include "wm.h"
   7 #include "window.h"
   8 #include "mouse.h"
   9 #include "mouse_cursor.h"
  10
  11 WindowManager *wm;
  12 static WindowManager wminst;
  13
  14 static void display(Window *win);
  15 static void mouse(Window *win, int bn, bool pressed, int x, int y);
  16 static void motion(Window *win, int x, int y);
  17
  18 void WindowManager::create_frame(Window *win)
  19 {
  20         Window *frame = new Window;
  21         Window *parent = win->get_parent();
  22
  23         frame->set_display_callback(display);
  24         frame->set_mouse_button_callback(mouse);
  25         frame->set_mouse_motion_callback(motion);
  26         frame->set_focusable(false);
  27         frame->add_child(win);
  28
  29         windows.push_back(frame);
  30
  31         Rect win_rect = win->get_rect();
  32         frame->move(win_rect.x - frame_thickness,
  33                         win_rect.y - frame_thickness - titlebar_thickness);
  34         frame->resize(win_rect.width + frame_thickness * 2,
  35                         win_rect.height + frame_thickness * 2 + titlebar_thickness);
  36
  37         win->move(frame_thickness, frame_thickness + titlebar_thickness);
  38         parent->add_child(frame);
  39 }
  40
  41 void WindowManager::destroy_frame(Window *win)
  42 {
  43         Window *frame = win->parent;
  44         if(!frame) {
  45                 return;
  46         }
  47
  48         if(grab_win == win) {
  49                 release_mouse();
  50         }
  51
  52         std::list<Window*>::iterator it;
  53         it = std::find(windows.begin(), windows.end(), frame);
  54         if(it != windows.end()) {
  55                 root_win->add_child(win);
  56                 windows.erase(it);
  57                 delete frame;
  58         }
  59 }
  60
  61 WindowManager::WindowManager()
  62 {
  63         if(!wm) {
  64                 wm = this;
  65         } else {
  66                 throw std::runtime_error("Trying to create a second instance of WindowManager!\n");
  67         }
  68
  69         root_win = new Window;
  70         root_win->resize(get_screen_size().width, get_screen_size().height);
  71         root_win->move(0, 0);
  72         root_win->set_managed(false);
  73
  74         focused_win = 0;
  75
  76         bg_color[0] = 210;
  77         bg_color[1] = 106;
  78         bg_color[2] = 106;
  79
  80         frame_thickness = 8;
  81         titlebar_thickness = 16;
  82
  83         frame_fcolor[0] = frame_fcolor[1] = frame_fcolor[2] = 142;
  84         frame_ucolor[0] = frame_ucolor[1] = frame_ucolor[2] = 210;
  85
  86         mouse_cursor.set_image(mouse_cursor_width, mouse_cursor_height);
  87         unsigned char *pixels = mouse_cursor.get_image();
  88
  89         for(int i=0; i<mouse_cursor_height; i++) {
  90                 for(int j=0; j<mouse_cursor_width; j++) {
  91                         int val = mouse_cursor_bw[i * mouse_cursor_width + j];
  92                         *pixels++ = val;
  93                         *pixels++ = val;
  94                         *pixels++ = val;
  95                         *pixels++ = 255;
  96                 }
  97         }
  98 }
  99
 100 WindowManager::~WindowManager()
 101 {
 102         delete root_win;
 103 }
 104
 105 void WindowManager::invalidate_region(const Rect &rect)
 106 {
 107         dirty_rects.push_back(rect);
 108 }
 109
 110 void WindowManager::process_windows()
 111 {
 112         if(dirty_rects.empty()) {
 113                 return;
 114         }
 115
 116         std::list<Rect>::iterator drit = dirty_rects.begin();
 117         Rect uni = *drit++;
 118         while(drit != dirty_rects.end()) {
 119                 uni = rect_union(uni, *drit++);
 120         }
 121         dirty_rects.clear();
 122
 123         wait_vsync();
 124
 125         fill_rect(uni, bg_color[0], bg_color[1], bg_color[2]);
 126
 127         root_win->draw_children(uni);
 128
 129         // draw mouse cursor
 130         int mouse_x, mouse_y;
 131         get_pointer_pos(&mouse_x, &mouse_y);
 132
 133         blit_key(mouse_cursor.get_image(), mouse_cursor.get_rect(),
 134                         get_framebuffer(), get_screen_size(), mouse_x, mouse_y,
 135                         0, 0, 0);
 136
 137         Rect mouse_rect = {mouse_x, mouse_y, mouse_cursor.get_width(), mouse_cursor.get_height()};
 138         invalidate_region(mouse_rect);
 139
 140         gfx_update();
 141 }
 142
 143 void WindowManager::add_window(Window *win)
 144 {
 145         if(!win || win == root_win) {
 146                 return;
 147         }
 148
 149         root_win->add_child(win);
 150
 151         if(windows.empty()) {
 152                 focused_win = win;
 153         }
 154
 155         if(win->get_managed()) {
 156                 create_frame(win);
 157         }
 158
 159         windows.push_back(win);
 160 }
 161
 162 void WindowManager::remove_window(Window *win)
 163 {
 164         std::list<Window*>::iterator it;
 165         it = std::find(windows.begin(), windows.end(), win);
 166
 167         if(it != windows.end()) {
 168                 windows.erase(it);
 169         }
 170 }
 171
 172 void WindowManager::set_focused_window(Window *win)
 173 {
 174         if(win && win == focused_win) {
 175                 return;
 176         }
 177
 178         if(focused_win) {
 179                 // invalidate the frame (if any)
 180                 Window *parent = focused_win->get_parent();
 181                 if(parent && parent != root_win) {
 182                         parent->invalidate();
 183                 }
 184         }
 185
 186         if(!win) {
 187                 focused_win = 0;
 188                 return;
 189         }
 190
 191         if(win->get_focusable()) {
 192                 focused_win = win;
 193                 return;
 194         }
 195
 196         Window **children = win->get_children();
 197         for(int i=0; i<win->get_children_count(); i++) {
 198                 if(children[0]->get_focusable()) {
 199                         set_focused_window(children[0]);
 200                         return;
 201                 }
 202         }
 203
 204         focused_win = 0;
 205 }
 206
 207 const Window *WindowManager::get_focused_window() const
 208 {
 209         return focused_win;
 210 }
 211
 212 Window *WindowManager::get_focused_window()
 213 {
 214         return focused_win;
 215 }
 216
 217 Window *WindowManager::get_window_at_pos(int pointer_x, int pointer_y)
 218 {
 219         std::list<Window*>::reverse_iterator rit = windows.rbegin();
 220         while(rit != windows.rend()) {
 221                 Window *w = *rit++;
 222                 Window *parent = w->get_parent();
 223
 224                 if(parent == root_win && w->contains_point(pointer_x, pointer_y)) {
 225                         return w;
 226                 }
 227         }
 228
 229         return 0;
 230 }
 231
 232 Window *WindowManager::get_grab_window() const
 233 {
 234         return grab_win;
 235 }
 236
 237 void WindowManager::grab_mouse(Window *win)
 238 {
 239         grab_win = win;
 240 }
 241
 242 void WindowManager::release_mouse()
 243 {
 244         grab_win = 0;
 245 }
 246
 247 static void display(Window *win)
 248 {
 249         fill_rect(win->get_absolute_rect(), 255, 211, 5);
 250 }
 251
 252 static int prev_x, prev_y;
 253
 254 static void mouse(Window *win, int bn, bool pressed, int x, int y)
 255 {
 256         if(bn == 0) {
 257                 if(pressed) {
 258                         wm->grab_mouse(win);
 259                         prev_x = x;
 260                         prev_y = y;
 261                 }
 262                 else {
 263                         wm->release_mouse();
 264                 }
 265         }
 266 }
 267
 268 static void motion(Window *win, int x, int y)
 269 {
 270         int left_bn = get_button(0);
 271         if(left_bn) {
 272                 int dx = x - prev_x;
 273                 int dy = y - prev_y;
 274                 prev_x = x - dx;
 275                 prev_y = y - dy;
 276
 277                 Rect rect = win->get_rect();
 278                 win->move(rect.x + dx, rect.y + dy);
 279         }
 280 }