srcgl/glgtk/GLCapability.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * duit is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with duit; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  =
  26  * outPack = glgtk
  27  * outFile = GLCapability
  28  * strct   =
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    =
  32  * interf  =
  33  * class Code: Yes
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  * omit structs:
  40  * omit prefixes:
  41  * omit code:
  42  * imports:
  43  * structWrap:
  44  * local aliases:
  45  */
  46
  47 module glgtk.GLCapability;
  48
  49 private import glgtk.glgtktypes;
  50
  51 private import lib.glgtk;
  52
  53
  54 /**
  55  */
  56
  57 // SNEAKY MIXIN PROBLEM:
  58 //
  59 // These need to be public imports
  60 // or GLCompatibility will not compile
  61 // as a mixin in other modules!
  62
  63 // May as well be explicit about it:
  64
  65
  66 public import std.stdio;
  67 public import glgtk.GLWidget;
  68 private import glgdk.GLDrawable;
  69 public import gdk.Event;
  70 public import lib.gl;
  71
  72
  73 template GLCapability()
  74 {
  75
  76         GLfloat width = 0;
  77         GLfloat height = 0;
  78
  79         GLfloat getGLWidth()
  80         {
  81                 return width;
  82         }
  83         GLfloat getGLHeight()
  84         {
  85                 return height;
  86         }
  87
  88
  89         /**
  90          * Sets the GL capabilities for the widget
  91          */
  92         bit setGLCapability(GLConfig glConfig = null, int renderType = GLRenderType.RGBA_TYPE)
  93         {
  94                 if ( glConfig is null )
  95                 {
  96                         glConfig = new GLConfig(
  97                         GLConfigMode.MODE_RGB
  98                         | GLConfigMode.MODE_DEPTH
  99                         | GLConfigMode.MODE_DOUBLE,
 100                         GLConfigMode.MODE_RGB
 101                         | GLConfigMode.MODE_DEPTH
 102                         );
 103                 }
 104                 bit ok = setGLCapability(this, glConfig, null, true, renderType);
 105
 106                 return ok;
 107         }
 108
 109         /**
 110          * Set the GL capabilities for the widget
 111          */
 112         bit setGLCapability(Widget widget, GLConfig glConfig, GLContext shareList, bit direct, int renderType)
 113         {
 114                 GLWidget.setGLCapability(widget, glConfig, shareList, direct, renderType);
 115
 116                 addOnRealize(&realizeFrame);
 117                 addOnUnrealize(&realizeFrame);
 118                 addOnExpose(&exposeFrame);
 119                 addOnConfigure(&configureFrame);
 120                 addOnMap(&mapFrame);
 121                 addOnUnmap(&unmapFrame);
 122                 addOnVisibilityNotify(&visibilityFrame);
 123                 return true;
 124         }
 125
 126         /**
 127          * The widget should use this method to redraw it self at any time
 128          */
 129         public bit glDrawFrame()
 130         {
 131                 return glDrawFrame(this);
 132         }
 133
 134         /**
 135          * The application should use this method to redraw the scene at any time
 136          */
 137         bit glDrawFrame(Widget widget)
 138         {
 139                 //printf("GLCapabilityT.realizeFrame \n" );
 140                 GLContext context = GLWidget.getGLContext(widget);
 141                 GLDrawable drawable = GLWidget.getGLDrawable(widget);
 142
 143                 /*** OpenGL BEGIN ***/
 144                 if ( !drawable.glBegin(context) )
 145                 {
 146                         return false;
 147                 }
 148
 149                 /*** do user actions ***/
 150                 bit consumeEvent = typeof(this).drawGL(null);
 151
 152                 /*** flush ***/
 153                 if ( drawable.isDoubleBuffered() )
 154                 {
 155                         drawable.swapBuffers();
 156                 }
 157                 else
 158                 {
 159                         glFlush ();
 160                 }
 161
 162                 drawable.glEnd();
 163                 /*** OpenGL END ***/
 164                 return true;
 165
 166         }
 167
 168         bool alreadyRealized;
 169
 170         bool getAlreadyRealized()
 171         {
 172                 return alreadyRealized;
 173         }
 174
 175         void realizeFrame(Widget widget)
 176         {
 177                 alreadyRealized = true;
 178
 179                 //printf("GLCapabilityT.realizeFrame \n" );
 180                 GLContext context = GLWidget.getGLContext(widget);
 181                 GLDrawable drawable = GLWidget.getGLDrawable(widget);
 182
 183                 /*** OpenGL BEGIN ***/
 184                 if ( !drawable.glBegin(context) )
 185                 {
 186                         return false;
 187                 }
 188
 189                 /*** do user actions ***/
 190                 bit consumeEvent = typeof(this).initGL();
 191
 192                 /*** flush ***/
 193                 if ( drawable.isDoubleBuffered() )
 194                 {
 195                         drawable.swapBuffers();
 196                 }
 197                 else
 198                 {
 199                         glFlush ();
 200                 }
 201
 202                 drawable.glEnd();
 203                 /*** OpenGL END ***/
 204
 205                 //return consumeEvent;
 206         }
 207
 208         int exposeFrame(GdkEventExpose* event, Widget widget)
 209         {
 210                 //printf("GLCapabilityT.exposeFrame exposeFrame\n" );
 211                 GLContext context = GLWidget.getGLContext(widget);
 212                 GLDrawable drawable = GLWidget.getGLDrawable(widget);
 213
 214                 /*** OpenGL BEGIN ***/
 215                 if ( !drawable.glBegin(context) )
 216                 {
 217                         return false;
 218                 }
 219
 220                 /*** do user actions ***/
 221                 int consumeEvent = typeof(this).drawGL(event);
 222
 223                 /*** flush ***/
 224                 if ( drawable.isDoubleBuffered() )
 225                 {
 226                         drawable.swapBuffers();
 227                 }
 228                 else
 229                 {
 230                         glFlush ();
 231                 }
 232
 233                 drawable.glEnd();
 234                 /*** OpenGL END ***/
 235
 236                 return consumeEvent;
 237         }
 238
 239         private import std.gc;
 240
 241         int configureFrame(GdkEventConfigure* event, Widget widget)
 242         {
 243                 if ( event != null )
 244                 {
 245                         width = event.width;
 246                         height = event.height;
 247                 }
 248                 std.gc.disable();
 249                 //writefln("configureFrame 1");
 250                 //printf("GLCapabilityT.configureFrame \n" );
 251                 GLContext context = GLWidget.getGLContext(widget);
 252                 GLDrawable drawable = GLWidget.getGLDrawable(widget);
 253
 254                 /*** OpenGL BEGIN ***/
 255                 if ( !drawable.glBegin(context) )
 256                 {
 257                         return false;
 258                 }
 259
 260                 //writefln("configureFrame 2");
 261                 /*** do user actions ***/
 262                 int consumeEvent = typeof(this).resizeGL(event);
 263                 //printf("here\n");
 264                 //writefln("configureFrame 3");
 265
 266                 /*** flush ***/
 267                 if ( drawable.isDoubleBuffered() )
 268                 {
 269                         //writefln("configureFrame 4");
 270                         drawable.swapBuffers();
 271                         //writefln("configureFrame 5");
 272                 }
 273                 else
 274                 {
 275                         //writefln("configureFrame 6");
 276                         glFlush ();
 277                         //writefln("configureFrame 7");
 278                 }
 279
 280                 //writefln("configureFrame 8");
 281                 drawable.glEnd();
 282                 //writefln("configureFrame 9");
 283                 /*** OpenGL END ***/
 284
 285                 std.gc.enable();
 286                 return consumeEvent;
 287         }
 288
 289         void mapFrame(Widget widget)
 290         {
 291                 //printf("GLCapabilityT.mapFrame \n" );
 292                 GLContext context = GLWidget.getGLContext(widget);
 293                 GLDrawable drawable = GLWidget.getGLDrawable(widget);
 294
 295                 /*** OpenGL BEGIN ***/
 296                 if ( !drawable.glBegin(context) )
 297                 {
 298                         return false;
 299                 }
 300
 301                 /*** do user actions ***/
 302                 bit consumeEvent = typeof(this).onMap();
 303
 304                 /*** flush ***/
 305                 if ( drawable.isDoubleBuffered() )
 306                 {
 307                         drawable.swapBuffers();
 308                 }
 309                 else
 310                 {
 311                         glFlush ();
 312                 }
 313
 314                 drawable.glEnd();
 315                 /*** OpenGL END ***/
 316
 317                 //return consumeEvent;
 318         }
 319
 320         void unmapFrame(Widget widget)
 321         {
 322                 //printf("GLCapabilityT.unmapFrame \n" );
 323                 GLContext context = GLWidget.getGLContext(widget);
 324                 GLDrawable drawable = GLWidget.getGLDrawable(widget);
 325
 326                 /*** OpenGL BEGIN ***/
 327                 if ( !drawable.glBegin(context) )
 328                 {
 329                         return false;
 330                 }
 331
 332                 /*** do user actions ***/
 333                 bit consumeEvent = typeof(this).onUnmap();
 334
 335                 /*** flush ***/
 336                 if ( drawable.isDoubleBuffered() )
 337                 {
 338                         drawable.swapBuffers();
 339                 }
 340                 else
 341                 {
 342                         glFlush ();
 343                 }
 344
 345                 drawable.glEnd();
 346                 /*** OpenGL END ***/
 347
 348                 //return consumeEvent;
 349         }
 350
 351         int visibilityFrame(GdkEventVisibility* event, Widget widget)
 352         {
 353                 //printf("GLCapabilityT.visibilityFrame \n" );
 354                 GLContext context = GLWidget.getGLContext(widget);
 355                 GLDrawable drawable = GLWidget.getGLDrawable(widget);
 356
 357                 /*** OpenGL BEGIN ***/
 358                 if ( !drawable.glBegin(context) )
 359                 {
 360                         return false;
 361                 }
 362
 363                 /*** do user actions ***/
 364                 bool consumeEvent = typeof(this).onVisibility(event);
 365
 366                 /*** flush ***/
 367                 if ( drawable.isDoubleBuffered() )
 368                 {
 369                         drawable.swapBuffers();
 370                 }
 371                 else
 372                 {
 373                         glFlush ();
 374                 }
 375
 376                 drawable.glEnd();
 377                 /*** OpenGL END ***/
 378
 379                 return consumeEvent;
 380         }
 381
 382         bit onMap()
 383         {
 384                 //printf("GLCapabilityT.map \n" );
 385                 return true;
 386         }
 387
 388         bit onUnmap()
 389         {
 390                 //printf("GLCapabilityT.unmap \n" );
 391                 return true;
 392         }
 393
 394         bool onVisibility(GdkEventVisibility* event)
 395         {
 396                 //printf("GLCapabilityT.visibility \n" );
 397                 return true;
 398         }
 399 }
 400
 401 /**
 402  */
 403