mmswindowclass.cpp

00001 /***************************************************************************
00002  *   Copyright (C) 2005-2007 Stefan Schwarzer, Jens Schneider,             *
00003  *                           Matthias Hardt, Guido Madaus                  *
00004  *                                                                         *
00005  *   Copyright (C) 2007-2008 BerLinux Solutions GbR                        *
00006  *                           Stefan Schwarzer & Guido Madaus               *
00007  *                                                                         *
00008  *   Copyright (C) 2009-2013 BerLinux Solutions GmbH                       *
00009  *                                                                         *
00010  *   Authors:                                                              *
00011  *      Stefan Schwarzer   <stefan.schwarzer@diskohq.org>,                 *
00012  *      Matthias Hardt     <matthias.hardt@diskohq.org>,                   *
00013  *      Jens Schneider     <jens.schneider@diskohq.org>,                   *
00014  *      Guido Madaus       <guido.madaus@diskohq.org>,                     *
00015  *      Patrick Helterhoff <patrick.helterhoff@diskohq.org>,               *
00016  *      René Bählkow       <rene.baehlkow@diskohq.org>                     *
00017  *                                                                         *
00018  *   This library is free software; you can redistribute it and/or         *
00019  *   modify it under the terms of the GNU Lesser General Public            *
00020  *   License version 2.1 as published by the Free Software Foundation.     *
00021  *                                                                         *
00022  *   This library is distributed in the hope that it will be useful,       *
00023  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00024  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00025  *   Lesser General Public License for more details.                       *
00026  *                                                                         *
00027  *   You should have received a copy of the GNU Lesser General Public      *
00028  *   License along with this library; if not, write to the                 *
00029  *   Free Software Foundation, Inc.,                                       *
00030  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
00031  **************************************************************************/
00032 
00033 #include "mmsgui/theme/mmswindowclass.h"
00034 #include "mmsconfig/mmsconfigdata.h"
00035 #include <string.h>
00036 
00037 MMSWindowClass::MMSWindowClass() {
00038     initAlignment();
00039     initDx();
00040     initDy();
00041     initWidth();
00042     initHeight();
00043     initBgColor();
00044     initBgImagePath();
00045     initBgImageName();
00046     initOpacity();
00047     initFadeIn();
00048     initFadeOut();
00049     initDebug();
00050     initMargin();
00051     initUpArrow();
00052     initDownArrow();
00053     initLeftArrow();
00054     initRightArrow();
00055     initNavigateUp();
00056     initNavigateDown();
00057     initNavigateLeft();
00058     initNavigateRight();
00059     initOwnSurface();
00060     initMoveIn();
00061     initMoveOut();
00062     initModal();
00063     initStaticZOrder();
00064     initAlwaysOnTop();
00065     initFocusable();
00066     initBackBuffer();
00067     initInitialLoad();
00068 }
00069 
00070 MMSWindowClass::~MMSWindowClass() {
00071     freeAlignment();
00072     freeDx();
00073     freeDy();
00074     freeWidth();
00075     freeHeight();
00076     freeBgColor();
00077     freeBgImagePath();
00078     freeBgImageName();
00079     freeOpacity();
00080     freeFadeIn();
00081     freeFadeOut();
00082     freeDebug();
00083     freeMargin();
00084     freeUpArrow();
00085     freeDownArrow();
00086     freeLeftArrow();
00087     freeRightArrow();
00088     freeNavigateUp();
00089     freeNavigateDown();
00090     freeNavigateLeft();
00091     freeNavigateRight();
00092     freeOwnSurface();
00093     freeMoveIn();
00094     freeMoveOut();
00095     freeModal();
00096     freeStaticZOrder();
00097     freeAlwaysOnTop();
00098     freeFocusable();
00099     freeBackBuffer();
00100     freeInitialLoad();
00101 }
00102 
00103 MMSWindowClass &MMSWindowClass::operator=(const MMSWindowClass &c) {
00104     if (this != &c) {
00105         /* copy internal fix data area */
00106         this->border = c.border;
00107         this->id = c.id;
00108 
00109         /* copy external data */
00110         memset(&(this->ed), 0, sizeof(this->ed));
00111         if (c.id.isdx)
00112             this->ed.dx = new string(*c.ed.dx);
00113         if (c.id.isdy)
00114             this->ed.dy = new string(*c.ed.dy);
00115         if (c.id.iswidth)
00116             this->ed.width = new string(*c.ed.width);
00117         if (c.id.isheight)
00118             this->ed.height = new string(*c.ed.height);
00119         if (c.id.isbgimagepath)
00120             this->ed.bgimagepath = new string(*c.ed.bgimagepath);
00121         if (c.id.isbgimagename)
00122             this->ed.bgimagename = new string(*c.ed.bgimagename);
00123         if (c.id.isuparrow)
00124             this->ed.uparrow = new string(*c.ed.uparrow);
00125         if (c.id.isdownarrow)
00126             this->ed.downarrow = new string(*c.ed.downarrow);
00127         if (c.id.isleftarrow)
00128             this->ed.leftarrow = new string(*c.ed.leftarrow);
00129         if (c.id.isrightarrow)
00130             this->ed.rightarrow = new string(*c.ed.rightarrow);
00131         if (c.id.isnavigateup)
00132             this->ed.navigateup = new string(*c.ed.navigateup);
00133         if (c.id.isnavigatedown)
00134             this->ed.navigatedown = new string(*c.ed.navigatedown);
00135         if (c.id.isnavigateleft)
00136             this->ed.navigateleft = new string(*c.ed.navigateleft);
00137         if (c.id.isnavigateright)
00138             this->ed.navigateright = new string(*c.ed.navigateright);
00139     }
00140     return *this;
00141 }
00142 
00143 void MMSWindowClass::unsetAll() {
00144     unsetAlignment();
00145     unsetDx();
00146     unsetDy();
00147     unsetWidth();
00148     unsetHeight();
00149     unsetBgColor();
00150     unsetBgImagePath();
00151     unsetBgImageName();
00152     unsetOpacity();
00153     unsetFadeIn();
00154     unsetFadeOut();
00155     unsetDebug();
00156     unsetMargin();
00157     unsetUpArrow();
00158     unsetDownArrow();
00159     unsetLeftArrow();
00160     unsetRightArrow();
00161     unsetNavigateUp();
00162     unsetNavigateDown();
00163     unsetNavigateLeft();
00164     unsetNavigateRight();
00165     unsetOwnSurface();
00166     unsetMoveIn();
00167     unsetMoveOut();
00168     unsetModal();
00169     unsetStaticZOrder();
00170     unsetAlwaysOnTop();
00171     unsetFocusable();
00172     unsetBackBuffer();
00173     unsetInitialLoad();
00174 }
00175 
00176 void MMSWindowClass::setAttributesFromTAFF(MMSTaffFile *tafff, string *path, bool reset_paths) {
00177     MMSFBColor color;
00178 
00179     if ((reset_paths)&&(path)&&(*path!="")) {
00180         // unset my paths
00181         unsetBgImagePath();
00182     }
00183 
00184     startTAFFScan
00185     {
00186         switch (attrid) {
00187         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_alignment:
00188             setAlignment(getAlignmentFromString(attrval_str));
00189             break;
00190         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_dx:
00191             setDx(attrval_str);
00192             break;
00193         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_dy:
00194             setDy(attrval_str);
00195             break;
00196         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_w:
00197             setWidth(attrval_str);
00198             break;
00199         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_h:
00200             setHeight(attrval_str);
00201             break;
00202         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_bgcolor:
00203             setBgColor(MMSFBColor((unsigned int)attrval_int));
00204             break;
00205         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_bgcolor_a:
00206             color.a = color.r = color.g = color.b = 0;
00207             if (isBgColor()) getBgColor(color);
00208             color.a = attrval_int;
00209             setBgColor(color);
00210             break;
00211         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_bgcolor_r:
00212             color.a = color.r = color.g = color.b = 0;
00213             if (isBgColor()) getBgColor(color);
00214             color.r = attrval_int;
00215             setBgColor(color);
00216             break;
00217         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_bgcolor_g:
00218             color.a = color.r = color.g = color.b = 0;
00219             if (isBgColor()) getBgColor(color);
00220             color.g = attrval_int;
00221             setBgColor(color);
00222             break;
00223         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_bgcolor_b:
00224             color.a = color.r = color.g = color.b = 0;
00225             if (isBgColor()) getBgColor(color);
00226             color.b = attrval_int;
00227             setBgColor(color);
00228             break;
00229         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_bgimage:
00230             if (*attrval_str)
00231                 setBgImagePath("");
00232             else
00233                 setBgImagePath((path)?*path:"");
00234             setBgImageName(attrval_str);
00235             break;
00236         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_bgimage_path:
00237             if (*attrval_str)
00238                 setBgImagePath(attrval_str);
00239             else
00240                 setBgImagePath((path)?*path:"");
00241             break;
00242         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_bgimage_name:
00243             setBgImageName(attrval_str);
00244             break;
00245         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_opacity:
00246             setOpacity(attrval_int);
00247             break;
00248         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_fadein:
00249             setFadeIn((attrval_int) ? true : false);
00250             break;
00251         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_fadeout:
00252             setFadeOut((attrval_int) ? true : false);
00253             break;
00254         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_debug:
00255             setDebug((attrval_int) ? true : false);
00256             break;
00257         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_margin:
00258             setMargin(attrval_int);
00259             break;
00260         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_up_arrow:
00261             setUpArrow(attrval_str);
00262             break;
00263         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_down_arrow:
00264             setDownArrow(attrval_str);
00265             break;
00266         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_left_arrow:
00267             setLeftArrow(attrval_str);
00268             break;
00269         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_right_arrow:
00270             setRightArrow(attrval_str);
00271             break;
00272         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_navigate_up:
00273             setNavigateUp(attrval_str);
00274             break;
00275         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_navigate_down:
00276             setNavigateDown(attrval_str);
00277             break;
00278         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_navigate_left:
00279             setNavigateLeft(attrval_str);
00280             break;
00281         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_navigate_right:
00282             setNavigateRight(attrval_str);
00283             break;
00284         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_own_surface:
00285 #ifdef __HAVE_DIRECTFB__
00286             if(attrval_int) {
00287                 MMSConfigData config;
00288                 if(config.getBackend() == MMSFB_BE_DFB) {
00289                     cerr << "Warning: DirectFB backend does not support own_surface=true (ignored)" << endl;
00290                     break;
00291                 }
00292             }
00293 #endif
00294             setOwnSurface((attrval_int) ? true : false);
00295             break;
00296         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_movein:
00297             setMoveIn(getDirectionFromString(attrval_str));
00298             break;
00299         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_moveout:
00300             setMoveOut(getDirectionFromString(attrval_str));
00301             break;
00302         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_modal:
00303             setModal((attrval_int) ? true : false);
00304             break;
00305         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_static_zorder:
00306             setStaticZOrder((attrval_int) ? true : false);
00307             break;
00308         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_always_on_top:
00309             setAlwaysOnTop((attrval_int) ? true : false);
00310             break;
00311         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_focusable:
00312             setFocusable((attrval_int) ? true : false);
00313             break;
00314         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_backbuffer:
00315             setBackBuffer((attrval_int) ? true : false);
00316             break;
00317         case MMSGUI_WINDOW_ATTR::MMSGUI_WINDOW_ATTR_IDS_initial_load:
00318             setInitialLoad((attrval_int) ? true : false);
00319             break;
00320         }
00321     }
00322     endTAFFScan
00323 
00324     if ((reset_paths)&&(path)&&(*path!="")) {
00325         // set my paths
00326         if (!isBgImagePath())
00327             setBgImagePath(*path);
00328     }
00329 }
00330 
00331 void MMSWindowClass::initAlignment() {
00332     MMSTHEMECLASS_INIT_BASIC(alignment);
00333 }
00334 
00335 void MMSWindowClass::freeAlignment() {
00336     MMSTHEMECLASS_FREE_BASIC(alignment);
00337 }
00338 
00339 bool MMSWindowClass::isAlignment() {
00340     MMSTHEMECLASS_ISSET(alignment);
00341 }
00342 
00343 void MMSWindowClass::unsetAlignment() {
00344     MMSTHEMECLASS_UNSET(alignment);
00345 }
00346 
00347 void MMSWindowClass::setAlignment(MMSALIGNMENT alignment) {
00348     MMSTHEMECLASS_SET_BASIC(alignment);
00349 }
00350 
00351 bool MMSWindowClass::getAlignment(MMSALIGNMENT &alignment) {
00352     MMSTHEMECLASS_GET_BASIC(alignment);
00353 }
00354 
00355 void MMSWindowClass::initDx() {
00356     MMSTHEMECLASS_INIT_STRING(dx);
00357 }
00358 
00359 void MMSWindowClass::freeDx() {
00360     MMSTHEMECLASS_FREE_STRING(dx);
00361 }
00362 
00363 bool MMSWindowClass::isDx() {
00364     MMSTHEMECLASS_ISSET(dx);
00365 }
00366 
00367 void MMSWindowClass::unsetDx() {
00368     MMSTHEMECLASS_UNSET(dx);
00369 }
00370 
00371 void MMSWindowClass::setDx(const string &dx) {
00372     MMSTHEMECLASS_SET_STRING(dx);
00373 }
00374 
00375 bool MMSWindowClass::getDx(string &dx) {
00376     MMSTHEMECLASS_GET_STRING(dx);
00377 }
00378 
00379 void MMSWindowClass::initDy() {
00380     MMSTHEMECLASS_INIT_STRING(dy);
00381 }
00382 
00383 void MMSWindowClass::freeDy() {
00384     MMSTHEMECLASS_FREE_STRING(dy);
00385 }
00386 
00387 bool MMSWindowClass::isDy() {
00388     MMSTHEMECLASS_ISSET(dy);
00389 }
00390 
00391 void MMSWindowClass::unsetDy() {
00392     MMSTHEMECLASS_UNSET(dy);
00393 }
00394 
00395 void MMSWindowClass::setDy(const string &dy) {
00396     MMSTHEMECLASS_SET_STRING(dy);
00397 }
00398 
00399 bool MMSWindowClass::getDy(string &dy) {
00400     MMSTHEMECLASS_GET_STRING(dy);
00401 }
00402 
00403 void MMSWindowClass::initWidth() {
00404     MMSTHEMECLASS_INIT_STRING(width);
00405 }
00406 
00407 void MMSWindowClass::freeWidth() {
00408     MMSTHEMECLASS_FREE_STRING(width);
00409 }
00410 
00411 bool MMSWindowClass::isWidth() {
00412     MMSTHEMECLASS_ISSET(width);
00413 }
00414 
00415 void MMSWindowClass::unsetWidth() {
00416     MMSTHEMECLASS_UNSET(width);
00417 }
00418 
00419 void MMSWindowClass::setWidth(const string &width) {
00420     MMSTHEMECLASS_SET_STRING(width);
00421 }
00422 
00423 bool MMSWindowClass::getWidth(string &width) {
00424     MMSTHEMECLASS_GET_STRING(width);
00425 }
00426 
00427 void MMSWindowClass::initHeight() {
00428     MMSTHEMECLASS_INIT_STRING(height);
00429 }
00430 
00431 void MMSWindowClass::freeHeight() {
00432     MMSTHEMECLASS_FREE_STRING(height);
00433 }
00434 
00435 bool MMSWindowClass::isHeight() {
00436     MMSTHEMECLASS_ISSET(height);
00437 }
00438 
00439 void MMSWindowClass::unsetHeight() {
00440     MMSTHEMECLASS_UNSET(height);
00441 }
00442 
00443 void MMSWindowClass::setHeight(const string &height) {
00444     MMSTHEMECLASS_SET_STRING(height);
00445 }
00446 
00447 bool MMSWindowClass::getHeight(string &height) {
00448     MMSTHEMECLASS_GET_STRING(height);
00449 }
00450 
00451 void MMSWindowClass::initBgColor() {
00452     MMSTHEMECLASS_INIT_BASIC(bgcolor);
00453 }
00454 
00455 void MMSWindowClass::freeBgColor() {
00456     MMSTHEMECLASS_FREE_BASIC(bgcolor);
00457 }
00458 
00459 bool MMSWindowClass::isBgColor() {
00460     MMSTHEMECLASS_ISSET(bgcolor);
00461 }
00462 
00463 void MMSWindowClass::unsetBgColor() {
00464     MMSTHEMECLASS_UNSET(bgcolor);
00465 }
00466 
00467 void MMSWindowClass::setBgColor(const MMSFBColor &bgcolor) {
00468     MMSTHEMECLASS_SET_BASIC(bgcolor);
00469 }
00470 
00471 bool MMSWindowClass::getBgColor(MMSFBColor &bgcolor) {
00472     MMSTHEMECLASS_GET_BASIC(bgcolor);
00473 }
00474 
00475 void MMSWindowClass::initBgImagePath() {
00476     MMSTHEMECLASS_INIT_STRING(bgimagepath);
00477 }
00478 
00479 void MMSWindowClass::freeBgImagePath() {
00480     MMSTHEMECLASS_FREE_STRING(bgimagepath);
00481 }
00482 
00483 bool MMSWindowClass::isBgImagePath() {
00484     MMSTHEMECLASS_ISSET(bgimagepath);
00485 }
00486 
00487 void MMSWindowClass::unsetBgImagePath() {
00488     MMSTHEMECLASS_UNSET(bgimagepath);
00489 }
00490 
00491 void MMSWindowClass::setBgImagePath(const string &bgimagepath) {
00492     MMSTHEMECLASS_SET_STRING(bgimagepath);
00493 }
00494 
00495 bool MMSWindowClass::getBgImagePath(string &bgimagepath) {
00496     MMSTHEMECLASS_GET_STRING(bgimagepath);
00497 }
00498 
00499 void MMSWindowClass::initBgImageName() {
00500     MMSTHEMECLASS_INIT_STRING(bgimagename);
00501 }
00502 
00503 void MMSWindowClass::freeBgImageName() {
00504     MMSTHEMECLASS_FREE_STRING(bgimagename);
00505 }
00506 
00507 bool MMSWindowClass::isBgImageName() {
00508     MMSTHEMECLASS_ISSET(bgimagename);
00509 }
00510 
00511 void MMSWindowClass::unsetBgImageName() {
00512     MMSTHEMECLASS_UNSET(bgimagename);
00513 }
00514 
00515 void MMSWindowClass::setBgImageName(const string &bgimagename) {
00516     MMSTHEMECLASS_SET_STRING(bgimagename);
00517 }
00518 
00519 bool MMSWindowClass::getBgImageName(string &bgimagename) {
00520     MMSTHEMECLASS_GET_STRING(bgimagename);
00521 }
00522 
00523 void MMSWindowClass::initOpacity() {
00524     MMSTHEMECLASS_INIT_BASIC(opacity);
00525 }
00526 
00527 void MMSWindowClass::freeOpacity() {
00528     MMSTHEMECLASS_FREE_BASIC(opacity);
00529 }
00530 
00531 bool MMSWindowClass::isOpacity() {
00532     MMSTHEMECLASS_ISSET(opacity);
00533 }
00534 
00535 void MMSWindowClass::unsetOpacity() {
00536     MMSTHEMECLASS_UNSET(opacity);
00537 }
00538 
00539 void MMSWindowClass::setOpacity(unsigned int opacity) {
00540     MMSTHEMECLASS_SET_BASIC(opacity);
00541 }
00542 
00543 bool MMSWindowClass::getOpacity(unsigned int &opacity) {
00544     MMSTHEMECLASS_GET_BASIC(opacity);
00545 }
00546 
00547 void MMSWindowClass::initFadeIn() {
00548     MMSTHEMECLASS_INIT_BASIC(fadein);
00549 }
00550 
00551 void MMSWindowClass::freeFadeIn() {
00552     MMSTHEMECLASS_FREE_BASIC(fadein);
00553 }
00554 
00555 bool MMSWindowClass::isFadeIn() {
00556     MMSTHEMECLASS_ISSET(fadein);
00557 }
00558 
00559 void MMSWindowClass::unsetFadeIn() {
00560     MMSTHEMECLASS_UNSET(fadein);
00561 }
00562 
00563 void MMSWindowClass::setFadeIn(bool fadein) {
00564     MMSTHEMECLASS_SET_BASIC(fadein);
00565 }
00566 
00567 bool MMSWindowClass::getFadeIn(bool &fadein) {
00568     MMSTHEMECLASS_GET_BASIC(fadein);
00569 }
00570 
00571 void MMSWindowClass::initFadeOut() {
00572     MMSTHEMECLASS_INIT_BASIC(fadeout);
00573 }
00574 
00575 void MMSWindowClass::freeFadeOut() {
00576     MMSTHEMECLASS_FREE_BASIC(fadeout);
00577 }
00578 
00579 bool MMSWindowClass::isFadeOut() {
00580     MMSTHEMECLASS_ISSET(fadeout);
00581 }
00582 
00583 void MMSWindowClass::unsetFadeOut() {
00584     MMSTHEMECLASS_UNSET(fadeout);
00585 }
00586 
00587 void MMSWindowClass::setFadeOut(bool fadeout) {
00588     MMSTHEMECLASS_SET_BASIC(fadeout);
00589 }
00590 
00591 bool MMSWindowClass::getFadeOut(bool &fadeout) {
00592     MMSTHEMECLASS_GET_BASIC(fadeout);
00593 }
00594 
00595 void MMSWindowClass::initDebug() {
00596     MMSTHEMECLASS_INIT_BASIC(debug);
00597 }
00598 
00599 void MMSWindowClass::freeDebug() {
00600     MMSTHEMECLASS_FREE_BASIC(debug);
00601 }
00602 
00603 bool MMSWindowClass::isDebug() {
00604     MMSTHEMECLASS_ISSET(debug);
00605 }
00606 
00607 void MMSWindowClass::unsetDebug() {
00608     MMSTHEMECLASS_UNSET(debug);
00609 }
00610 
00611 void MMSWindowClass::setDebug(bool debug) {
00612     MMSTHEMECLASS_SET_BASIC(debug);
00613 }
00614 
00615 bool MMSWindowClass::getDebug(bool &debug) {
00616     MMSTHEMECLASS_GET_BASIC(debug);
00617 }
00618 
00619 void MMSWindowClass::initMargin() {
00620     MMSTHEMECLASS_INIT_BASIC(margin);
00621 }
00622 
00623 void MMSWindowClass::freeMargin() {
00624     MMSTHEMECLASS_FREE_BASIC(margin);
00625 }
00626 
00627 bool MMSWindowClass::isMargin() {
00628     MMSTHEMECLASS_ISSET(margin);
00629 }
00630 
00631 void MMSWindowClass::unsetMargin() {
00632     MMSTHEMECLASS_UNSET(margin);
00633 }
00634 
00635 void MMSWindowClass::setMargin(unsigned int margin) {
00636     MMSTHEMECLASS_SET_BASIC(margin);
00637 }
00638 
00639 bool MMSWindowClass::getMargin(unsigned int &margin) {
00640     MMSTHEMECLASS_GET_BASIC(margin);
00641 }
00642 
00643 void MMSWindowClass::initUpArrow() {
00644     MMSTHEMECLASS_INIT_STRING(uparrow);
00645 }
00646 
00647 void MMSWindowClass::freeUpArrow() {
00648     MMSTHEMECLASS_FREE_STRING(uparrow);
00649 }
00650 
00651 bool MMSWindowClass::isUpArrow() {
00652     MMSTHEMECLASS_ISSET(uparrow);
00653 }
00654 
00655 void MMSWindowClass::unsetUpArrow() {
00656     MMSTHEMECLASS_UNSET(uparrow);
00657 }
00658 
00659 void MMSWindowClass::setUpArrow(const string &uparrow) {
00660     MMSTHEMECLASS_SET_STRING(uparrow);
00661 }
00662 
00663 bool MMSWindowClass::getUpArrow(string &uparrow) {
00664     MMSTHEMECLASS_GET_STRING(uparrow);
00665 }
00666 
00667 void MMSWindowClass::initDownArrow() {
00668     MMSTHEMECLASS_INIT_STRING(downarrow);
00669 }
00670 
00671 void MMSWindowClass::freeDownArrow() {
00672     MMSTHEMECLASS_FREE_STRING(downarrow);
00673 }
00674 
00675 bool MMSWindowClass::isDownArrow() {
00676     MMSTHEMECLASS_ISSET(downarrow);
00677 }
00678 
00679 void MMSWindowClass::unsetDownArrow() {
00680     MMSTHEMECLASS_UNSET(downarrow);
00681 }
00682 
00683 void MMSWindowClass::setDownArrow(const string &downarrow) {
00684     MMSTHEMECLASS_SET_STRING(downarrow);
00685 }
00686 
00687 bool MMSWindowClass::getDownArrow(string &downarrow) {
00688     MMSTHEMECLASS_GET_STRING(downarrow);
00689 }
00690 
00691 void MMSWindowClass::initLeftArrow() {
00692     MMSTHEMECLASS_INIT_STRING(leftarrow);
00693 }
00694 
00695 void MMSWindowClass::freeLeftArrow() {
00696     MMSTHEMECLASS_FREE_STRING(leftarrow);
00697 }
00698 
00699 bool MMSWindowClass::isLeftArrow() {
00700     MMSTHEMECLASS_ISSET(leftarrow);
00701 }
00702 
00703 void MMSWindowClass::unsetLeftArrow() {
00704     MMSTHEMECLASS_UNSET(leftarrow);
00705 }
00706 
00707 void MMSWindowClass::setLeftArrow(const string &leftarrow) {
00708     MMSTHEMECLASS_SET_STRING(leftarrow);
00709 }
00710 
00711 bool MMSWindowClass::getLeftArrow(string &leftarrow) {
00712     MMSTHEMECLASS_GET_STRING(leftarrow);
00713 }
00714 
00715 void MMSWindowClass::initRightArrow() {
00716     MMSTHEMECLASS_INIT_STRING(rightarrow);
00717 }
00718 
00719 void MMSWindowClass::freeRightArrow() {
00720     MMSTHEMECLASS_FREE_STRING(rightarrow);
00721 }
00722 
00723 bool MMSWindowClass::isRightArrow() {
00724     MMSTHEMECLASS_ISSET(rightarrow);
00725 }
00726 
00727 void MMSWindowClass::unsetRightArrow() {
00728     MMSTHEMECLASS_UNSET(rightarrow);
00729 }
00730 
00731 void MMSWindowClass::setRightArrow(const string &rightarrow) {
00732     MMSTHEMECLASS_SET_STRING(rightarrow);
00733 }
00734 
00735 bool MMSWindowClass::getRightArrow(string &rightarrow) {
00736     MMSTHEMECLASS_GET_STRING(rightarrow);
00737 }
00738 
00739 void MMSWindowClass::initNavigateUp() {
00740     MMSTHEMECLASS_INIT_STRING(navigateup);
00741 }
00742 
00743 void MMSWindowClass::freeNavigateUp() {
00744     MMSTHEMECLASS_FREE_STRING(navigateup);
00745 }
00746 
00747 bool MMSWindowClass::isNavigateUp() {
00748     MMSTHEMECLASS_ISSET(navigateup);
00749 }
00750 
00751 void MMSWindowClass::unsetNavigateUp() {
00752     MMSTHEMECLASS_UNSET(navigateup);
00753 }
00754 
00755 void MMSWindowClass::setNavigateUp(const string &navigateup) {
00756     MMSTHEMECLASS_SET_STRING(navigateup);
00757 }
00758 
00759 bool MMSWindowClass::getNavigateUp(string &navigateup) {
00760     MMSTHEMECLASS_GET_STRING(navigateup);
00761 }
00762 
00763 void MMSWindowClass::initNavigateDown() {
00764     MMSTHEMECLASS_INIT_STRING(navigatedown);
00765 }
00766 
00767 void MMSWindowClass::freeNavigateDown() {
00768     MMSTHEMECLASS_FREE_STRING(navigatedown);
00769 }
00770 
00771 bool MMSWindowClass::isNavigateDown() {
00772     MMSTHEMECLASS_ISSET(navigatedown);
00773 }
00774 
00775 void MMSWindowClass::unsetNavigateDown() {
00776     MMSTHEMECLASS_UNSET(navigatedown);
00777 }
00778 
00779 void MMSWindowClass::setNavigateDown(const string &navigatedown) {
00780     MMSTHEMECLASS_SET_STRING(navigatedown);
00781 }
00782 
00783 bool MMSWindowClass::getNavigateDown(string &navigatedown) {
00784     MMSTHEMECLASS_GET_STRING(navigatedown);
00785 }
00786 
00787 void MMSWindowClass::initNavigateLeft() {
00788     MMSTHEMECLASS_INIT_STRING(navigateleft);
00789 }
00790 
00791 void MMSWindowClass::freeNavigateLeft() {
00792     MMSTHEMECLASS_FREE_STRING(navigateleft);
00793 }
00794 
00795 bool MMSWindowClass::isNavigateLeft() {
00796     MMSTHEMECLASS_ISSET(navigateleft);
00797 }
00798 
00799 void MMSWindowClass::unsetNavigateLeft() {
00800     MMSTHEMECLASS_UNSET(navigateleft);
00801 }
00802 
00803 void MMSWindowClass::setNavigateLeft(const string &navigateleft) {
00804     MMSTHEMECLASS_SET_STRING(navigateleft);
00805 }
00806 
00807 bool MMSWindowClass::getNavigateLeft(string &navigateleft) {
00808     MMSTHEMECLASS_GET_STRING(navigateleft);
00809 }
00810 
00811 void MMSWindowClass::initNavigateRight() {
00812     MMSTHEMECLASS_INIT_STRING(navigateright);
00813 }
00814 
00815 void MMSWindowClass::freeNavigateRight() {
00816     MMSTHEMECLASS_FREE_STRING(navigateright);
00817 }
00818 
00819 bool MMSWindowClass::isNavigateRight() {
00820     MMSTHEMECLASS_ISSET(navigateright);
00821 }
00822 
00823 void MMSWindowClass::unsetNavigateRight() {
00824     MMSTHEMECLASS_UNSET(navigateright);
00825 }
00826 
00827 void MMSWindowClass::setNavigateRight(const string &navigateright) {
00828     MMSTHEMECLASS_SET_STRING(navigateright);
00829 }
00830 
00831 bool MMSWindowClass::getNavigateRight(string &navigateright) {
00832     MMSTHEMECLASS_GET_STRING(navigateright);
00833 }
00834 
00835 void MMSWindowClass::initOwnSurface() {
00836     MMSTHEMECLASS_INIT_BASIC(ownsurface);
00837 }
00838 
00839 void MMSWindowClass::freeOwnSurface() {
00840     MMSTHEMECLASS_FREE_BASIC(ownsurface);
00841 }
00842 
00843 bool MMSWindowClass::isOwnSurface() {
00844     MMSTHEMECLASS_ISSET(ownsurface);
00845 }
00846 
00847 void MMSWindowClass::unsetOwnSurface() {
00848     MMSTHEMECLASS_UNSET(ownsurface);
00849 }
00850 
00851 void MMSWindowClass::setOwnSurface(bool ownsurface) {
00852     MMSTHEMECLASS_SET_BASIC(ownsurface);
00853 }
00854 
00855 bool MMSWindowClass::getOwnSurface(bool &ownsurface) {
00856     MMSTHEMECLASS_GET_BASIC(ownsurface);
00857 }
00858 
00859 void MMSWindowClass::initMoveIn() {
00860     MMSTHEMECLASS_INIT_BASIC(movein);
00861 }
00862 
00863 void MMSWindowClass::freeMoveIn() {
00864     MMSTHEMECLASS_FREE_BASIC(movein);
00865 }
00866 
00867 bool MMSWindowClass::isMoveIn() {
00868     MMSTHEMECLASS_ISSET(movein);
00869 }
00870 
00871 void MMSWindowClass::unsetMoveIn() {
00872     MMSTHEMECLASS_UNSET(movein);
00873 }
00874 
00875 void MMSWindowClass::setMoveIn(MMSDIRECTION movein) {
00876     MMSTHEMECLASS_SET_BASIC(movein);
00877 }
00878 
00879 bool MMSWindowClass::getMoveIn(MMSDIRECTION &movein) {
00880     MMSTHEMECLASS_GET_BASIC(movein);
00881 }
00882 
00883 
00884 void MMSWindowClass::initMoveOut() {
00885     MMSTHEMECLASS_INIT_BASIC(moveout);
00886 }
00887 
00888 void MMSWindowClass::freeMoveOut() {
00889     MMSTHEMECLASS_FREE_BASIC(moveout);
00890 }
00891 
00892 bool MMSWindowClass::isMoveOut() {
00893     MMSTHEMECLASS_ISSET(moveout);
00894 }
00895 
00896 void MMSWindowClass::unsetMoveOut() {
00897     MMSTHEMECLASS_UNSET(moveout);
00898 }
00899 
00900 void MMSWindowClass::setMoveOut(MMSDIRECTION moveout) {
00901     MMSTHEMECLASS_SET_BASIC(moveout);
00902 }
00903 
00904 bool MMSWindowClass::getMoveOut(MMSDIRECTION &moveout) {
00905     MMSTHEMECLASS_GET_BASIC(moveout);
00906 }
00907 
00908 void MMSWindowClass::initModal() {
00909     MMSTHEMECLASS_INIT_BASIC(modal);
00910 }
00911 
00912 void MMSWindowClass::freeModal() {
00913     MMSTHEMECLASS_FREE_BASIC(modal);
00914 }
00915 
00916 bool MMSWindowClass::isModal() {
00917     MMSTHEMECLASS_ISSET(modal);
00918 }
00919 
00920 void MMSWindowClass::unsetModal() {
00921     MMSTHEMECLASS_UNSET(modal);
00922 }
00923 
00924 void MMSWindowClass::setModal(bool modal) {
00925     MMSTHEMECLASS_SET_BASIC(modal);
00926 }
00927 
00928 bool MMSWindowClass::getModal(bool &modal) {
00929     MMSTHEMECLASS_GET_BASIC(modal);
00930 }
00931 
00932 
00933 void MMSWindowClass::initStaticZOrder() {
00934     MMSTHEMECLASS_INIT_BASIC(staticzorder);
00935 }
00936 
00937 void MMSWindowClass::freeStaticZOrder() {
00938     MMSTHEMECLASS_FREE_BASIC(staticzorder);
00939 }
00940 
00941 bool MMSWindowClass::isStaticZOrder() {
00942     MMSTHEMECLASS_ISSET(staticzorder);
00943 }
00944 
00945 void MMSWindowClass::unsetStaticZOrder() {
00946     MMSTHEMECLASS_UNSET(staticzorder);
00947 }
00948 
00949 void MMSWindowClass::setStaticZOrder(bool staticzorder) {
00950     MMSTHEMECLASS_SET_BASIC(staticzorder);
00951 }
00952 
00953 bool MMSWindowClass::getStaticZOrder(bool &staticzorder) {
00954     MMSTHEMECLASS_GET_BASIC(staticzorder);
00955 }
00956 
00957 void MMSWindowClass::initAlwaysOnTop() {
00958     MMSTHEMECLASS_INIT_BASIC(alwaysontop);
00959 }
00960 
00961 void MMSWindowClass::freeAlwaysOnTop() {
00962     MMSTHEMECLASS_FREE_BASIC(alwaysontop);
00963 }
00964 
00965 bool MMSWindowClass::isAlwaysOnTop() {
00966     MMSTHEMECLASS_ISSET(alwaysontop);
00967 }
00968 
00969 void MMSWindowClass::unsetAlwaysOnTop() {
00970     MMSTHEMECLASS_UNSET(alwaysontop);
00971 }
00972 
00973 void MMSWindowClass::setAlwaysOnTop(bool alwaysontop) {
00974     MMSTHEMECLASS_SET_BASIC(alwaysontop);
00975 }
00976 
00977 bool MMSWindowClass::getAlwaysOnTop(bool &alwaysontop) {
00978     MMSTHEMECLASS_GET_BASIC(alwaysontop);
00979 }
00980 
00981 void MMSWindowClass::initFocusable() {
00982     MMSTHEMECLASS_INIT_BASIC(focusable);
00983 }
00984 
00985 void MMSWindowClass::freeFocusable() {
00986     MMSTHEMECLASS_FREE_BASIC(focusable);
00987 }
00988 
00989 bool MMSWindowClass::isFocusable() {
00990     MMSTHEMECLASS_ISSET(focusable);
00991 }
00992 
00993 void MMSWindowClass::unsetFocusable() {
00994     MMSTHEMECLASS_UNSET(focusable);
00995 }
00996 
00997 void MMSWindowClass::setFocusable(bool focusable) {
00998     MMSTHEMECLASS_SET_BASIC(focusable);
00999 }
01000 
01001 bool MMSWindowClass::getFocusable(bool &focusable) {
01002     MMSTHEMECLASS_GET_BASIC(focusable);
01003 }
01004 
01005 void MMSWindowClass::initBackBuffer() {
01006     MMSTHEMECLASS_INIT_BASIC(backbuffer);
01007 }
01008 
01009 void MMSWindowClass::freeBackBuffer() {
01010     MMSTHEMECLASS_FREE_BASIC(backbuffer);
01011 }
01012 
01013 bool MMSWindowClass::isBackBuffer() {
01014     MMSTHEMECLASS_ISSET(backbuffer);
01015 }
01016 
01017 void MMSWindowClass::unsetBackBuffer() {
01018     MMSTHEMECLASS_UNSET(backbuffer);
01019 }
01020 
01021 void MMSWindowClass::setBackBuffer(bool backbuffer) {
01022     MMSTHEMECLASS_SET_BASIC(backbuffer);
01023 }
01024 
01025 bool MMSWindowClass::getBackBuffer(bool &backbuffer) {
01026     MMSTHEMECLASS_GET_BASIC(backbuffer);
01027 }
01028 
01029 void MMSWindowClass::initInitialLoad() {
01030     MMSTHEMECLASS_INIT_BASIC(initialload);
01031 }
01032 
01033 void MMSWindowClass::freeInitialLoad() {
01034     MMSTHEMECLASS_FREE_BASIC(initialload);
01035 }
01036 
01037 bool MMSWindowClass::isInitialLoad() {
01038     MMSTHEMECLASS_ISSET(initialload);
01039 }
01040 
01041 void MMSWindowClass::unsetInitialLoad() {
01042     MMSTHEMECLASS_UNSET(initialload);
01043 }
01044 
01045 void MMSWindowClass::setInitialLoad(bool initialload) {
01046     MMSTHEMECLASS_SET_BASIC(initialload);
01047 }
01048 
01049 bool MMSWindowClass::getInitialLoad(bool &initialload) {
01050     MMSTHEMECLASS_GET_BASIC(initialload);
01051 }
01052