hvirtual/guicast/bcpixmap.C

   1 #include "bcbitmap.h"
   2 #include "bcpixmap.h"
   3 #include "bcwindowbase.h"
   4 #include "vframe.h"
   5
   6
   7 #include <unistd.h>
   8
   9 BC_Pixmap::BC_Pixmap(BC_WindowBase *parent_window,
  10         VFrame *frame,
  11         int mode,
  12         int icon_offset)
  13 {
  14         BC_Bitmap *opaque_bitmap, *alpha_bitmap, *mask_bitmap;
  15         if(frame->get_color_model() != BC_RGBA8888 &&
  16                 mode == PIXMAP_ALPHA)
  17                 mode = PIXMAP_OPAQUE;
  18         this->mode = mode;
  19
  20 // Temporary bitmaps
  21         if(use_opaque())
  22         {
  23                 opaque_bitmap = new BC_Bitmap(parent_window,
  24                                         frame->get_w(),
  25                                         frame->get_h(),
  26                                         parent_window->get_color_model(),
  27                                         0);
  28                 opaque_bitmap->set_bg_color(parent_window->get_bg_color());
  29                 opaque_bitmap->read_frame(frame,
  30                         0,
  31                         0,
  32                         frame->get_w(),
  33                         frame->get_h());
  34
  35         }
  36
  37         if(use_alpha())
  38         {
  39                 alpha_bitmap = new BC_Bitmap(parent_window,
  40                                 frame->get_w(),
  41                                 frame->get_h(),
  42                                 BC_TRANSPARENCY,
  43                                 0);
  44
  45                 if(frame->get_color_model() != BC_RGBA8888)
  46                         printf("BC_Pixmap::BC_Pixmap: PIXMAP_ALPHA but frame doesn't have alpha.\n");
  47                 alpha_bitmap->read_frame(frame,
  48                         0,
  49                         0,
  50                         frame->get_w(),
  51                         frame->get_h());
  52         }
  53
  54         initialize(parent_window,
  55                 frame->get_w(),
  56                 frame->get_h(),
  57                 mode);
  58
  59         if(use_opaque())
  60         {
  61                 opaque_bitmap->write_drawable(opaque_pixmap,
  62                                                                 top_level->gc,
  63                                                                 0,
  64                                                                 0,
  65                                                                 0,
  66                                                                 0,
  67                                                                 w,
  68                                                                 h,
  69                                                                 1);
  70                 delete opaque_bitmap;
  71         }
  72
  73         if(use_alpha())
  74         {
  75                 alpha_bitmap->write_drawable(alpha_pixmap,
  76                         copy_gc,
  77                         0,
  78                         0,
  79                         icon_offset ? 2 : 0,
  80                         icon_offset ? 2 : 0,
  81                         w,
  82                         h,
  83                         1);
  84                 delete alpha_bitmap;
  85                 XFreeGC(top_level->display, copy_gc);
  86
  87                 XSetClipMask(top_level->display, alpha_gc, alpha_pixmap);
  88         }
  89 }
  90
  91 BC_Pixmap::BC_Pixmap(BC_WindowBase *parent_window, int w, int h)
  92 {
  93         initialize(parent_window, w, h, PIXMAP_OPAQUE);
  94 }
  95
  96
  97 BC_Pixmap::~BC_Pixmap()
  98 {
  99         if(use_opaque())
 100         {
 101                 XFreePixmap(top_level->display, opaque_pixmap);
 102         }
 103
 104         if(use_alpha())
 105         {
 106                 XFreeGC(top_level->display, alpha_gc);
 107                 XFreePixmap(top_level->display, alpha_pixmap);
 108         }
 109 }
 110
 111 int BC_Pixmap::initialize(BC_WindowBase *parent_window, int w, int h, int mode)
 112 {
 113         unsigned long gcmask = GCGraphicsExposures | GCForeground | GCBackground | GCFunction;
 114         XGCValues gcvalues;
 115         gcvalues.graphics_exposures = 0;        // prevent expose events for every redraw
 116         gcvalues.foreground = 0;
 117         gcvalues.background = 1;
 118         gcvalues.function = GXcopy;
 119
 120         this->w = w;
 121         this->h = h;
 122         this->parent_window = parent_window;
 123         this->mode = mode;
 124         top_level = parent_window->top_level;
 125
 126         if(use_opaque())
 127         {
 128                 opaque_pixmap = XCreatePixmap(top_level->display,
 129                         top_level->win,
 130                         w,
 131                         h,
 132                         top_level->default_depth);
 133 #ifdef HAVE_XFT
 134                 opaque_xft_draw = XftDrawCreate(top_level->display,
 135                        opaque_pixmap,
 136                        top_level->vis,
 137                        top_level->cmap);
 138 #endif
 139         }
 140
 141         if(use_alpha())
 142         {
 143                 alpha_pixmap = XCreatePixmap(top_level->display,
 144                         top_level->win,
 145                         w,
 146                         h,
 147                         1);
 148
 149                 alpha_gc = XCreateGC(top_level->display,
 150                         top_level->win,
 151                         gcmask,
 152                         &gcvalues);
 153
 154                 copy_gc = XCreateGC(top_level->display,
 155                         alpha_pixmap,
 156                         gcmask,
 157                         &gcvalues);
 158
 159 #ifdef HAVE_XFT
 160                 alpha_xft_draw = XftDrawCreateBitmap(top_level->display,
 161                         alpha_pixmap);
 162 #endif
 163         }
 164
 165         return 0;
 166 }
 167
 168 void BC_Pixmap::resize(int w, int h)
 169 {
 170         Pixmap new_pixmap = XCreatePixmap(top_level->display,
 171                         top_level->win,
 172                         w,
 173                         h,
 174                         top_level->default_depth);
 175         XCopyArea(top_level->display,
 176                 opaque_pixmap,
 177                 new_pixmap,
 178                 top_level->gc,
 179                 0,
 180                 0,
 181                 get_w(),
 182                 get_h(),
 183                 0,
 184                 0);
 185         this->w = w;
 186         this->h = h;
 187         XFreePixmap(top_level->display, opaque_pixmap);
 188         opaque_pixmap = new_pixmap;
 189 }
 190
 191
 192 void BC_Pixmap::copy_area(int x, int y, int w, int h, int x2, int y2)
 193 {
 194         XCopyArea(top_level->display,
 195                 opaque_pixmap,
 196                 opaque_pixmap,
 197                 top_level->gc,
 198                 x,
 199                 y,
 200                 w,
 201                 h,
 202                 x2,
 203                 y2);
 204 }
 205
 206 int BC_Pixmap::write_drawable(Drawable &pixmap,
 207                         int dest_x,
 208                         int dest_y,
 209                         int dest_w,
 210                         int dest_h,
 211                         int src_x,
 212                         int src_y)
 213 {
 214 //printf("BC_Pixmap::write_drawable 1\n");
 215         if(dest_w < 0)
 216         {
 217                 dest_w = w;
 218                 src_x = 0;
 219         }
 220
 221         if(dest_h < 0)
 222         {
 223                 dest_h = h;
 224                 src_y = 0;
 225         }
 226
 227         if(use_alpha())
 228         {
 229                 XSetClipOrigin(top_level->display, alpha_gc, dest_x - src_x, dest_y - src_y);
 230                 XCopyArea(top_level->display,
 231                         this->opaque_pixmap,
 232                         pixmap,
 233                         alpha_gc,
 234                         src_x,
 235                         src_y,
 236                         dest_w,
 237                         dest_h,
 238                         dest_x,
 239                         dest_y);
 240         }
 241         else
 242         if(use_opaque())
 243         {
 244                 XCopyArea(top_level->display,
 245                         this->opaque_pixmap,
 246                         pixmap,
 247                         top_level->gc,
 248                         src_x,
 249                         src_y,
 250                         dest_w,
 251                         dest_h,
 252                         dest_x,
 253                         dest_y);
 254         }
 255 //printf("BC_Pixmap::write_drawable 2\n");
 256
 257         return 0;
 258 }
 259
 260 void BC_Pixmap::draw_vframe(VFrame *frame,
 261                 int dest_x,
 262                 int dest_y,
 263                 int dest_w,
 264                 int dest_h,
 265                 int src_x,
 266                 int src_y)
 267 {
 268         parent_window->draw_vframe(frame,
 269                 dest_x,
 270                 dest_y,
 271                 dest_w,
 272                 dest_h,
 273                 src_x,
 274                 src_y,
 275                 0,
 276                 0,
 277                 this);
 278 }
 279
 280 void BC_Pixmap::draw_pixmap(BC_Pixmap *pixmap,
 281         int dest_x,
 282         int dest_y,
 283         int dest_w,
 284         int dest_h,
 285         int src_x,
 286         int src_y)
 287 {
 288         pixmap->write_drawable(this->opaque_pixmap,
 289                         dest_x,
 290                         dest_y,
 291                         dest_w,
 292                         dest_h,
 293                         src_x,
 294                         src_y);
 295 }
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307 int BC_Pixmap::get_w()
 308 {
 309         return w;
 310 }
 311
 312 int BC_Pixmap::get_h()
 313 {
 314         return h;
 315 }
 316
 317 int BC_Pixmap::get_w_fixed()
 318 {
 319         return w - 1;
 320 }
 321
 322 int BC_Pixmap::get_h_fixed()
 323 {
 324         return h - 1;
 325 }
 326
 327 Pixmap BC_Pixmap::get_pixmap()
 328 {
 329         return opaque_pixmap;
 330 }
 331
 332 Pixmap BC_Pixmap::get_alpha()
 333 {
 334         return alpha_pixmap;
 335 }
 336
 337 int BC_Pixmap::use_opaque()
 338 {
 339         return 1;
 340 }
 341
 342 int BC_Pixmap::use_alpha()
 343 {
 344         return mode == PIXMAP_ALPHA;
 345 }