mmsmenuwidgetclass.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/mmsmenuwidgetclass.h"
00034 #include <string.h>
00035 
00036 //store attribute descriptions here
00037 TAFF_ATTRDESC MMSGUI_MENUWIDGET_ATTR_I[] = MMSGUI_MENUWIDGET_ATTR_INIT;
00038 
00039 // address attribute names
00040 #define GETATTRNAME(aname) MMSGUI_MENUWIDGET_ATTR_I[MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_##aname].name
00041 
00042 // address attribute types
00043 #define GETATTRTYPE(aname) MMSGUI_MENUWIDGET_ATTR_I[MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_##aname].type
00044 
00045 
00046 MMSMenuWidgetClass::MMSMenuWidgetClass() {
00047     this->tafff = NULL;
00048     unsetAll();
00049 }
00050 
00051 MMSMenuWidgetClass::~MMSMenuWidgetClass() {
00052     if (this->tafff)
00053         delete this->tafff;
00054     this->tafff = NULL;
00055 }
00056 
00057 void MMSMenuWidgetClass::unsetAll() {
00058     this->className = "";
00059     if (this->tafff)
00060         delete this->tafff;
00061     this->tafff = NULL;
00062     unsetItemWidth();
00063     unsetItemHeight();
00064     unsetItemHMargin();
00065     unsetItemVMargin();
00066     unsetCols();
00067     unsetDimItems();
00068     unsetFixedPos();
00069     unsetHLoop();
00070     unsetVLoop();
00071     unsetTransItems();
00072     unsetDimTop();
00073     unsetDimBottom();
00074     unsetDimLeft();
00075     unsetDimRight();
00076     unsetTransTop();
00077     unsetTransBottom();
00078     unsetTransLeft();
00079     unsetTransRight();
00080     unsetZoomSelWidth();
00081     unsetZoomSelHeight();
00082     unsetZoomSelShiftX();
00083     unsetZoomSelShiftY();
00084     unsetSmoothScrolling();
00085     unsetParentWindow();
00086     unsetSelImagePath();
00087     unsetSelImageName();
00088     unsetSmoothSelection();
00089     unsetSmoothDelay();
00090 }
00091 
00092 void MMSMenuWidgetClass::setAttributesFromTAFF(MMSTaffFile *tafff, string *prefix, string *path, bool reset_paths) {
00093 
00094     if ((reset_paths)&&(path)&&(*path!="")) {
00095         // unset my paths
00096         unsetSelImagePath();
00097     }
00098 
00099     if (!prefix) {
00100         startTAFFScan
00101         {
00102             switch (attrid) {
00103             case MMSGUI_BASE_ATTR::MMSGUI_BASE_ATTR_IDS_class:
00104                 setClassName(attrval_str);
00105                 break;
00106             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_item_width:
00107                 setItemWidth(attrval_str);
00108                 break;
00109             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_item_height:
00110                 setItemHeight(attrval_str);
00111                 break;
00112             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_item_hmargin:
00113                 setItemHMargin(attrval_int);
00114                 break;
00115             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_item_vmargin:
00116                 setItemVMargin(attrval_int);
00117                 break;
00118             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_cols:
00119                 setCols(attrval_int);
00120                 break;
00121             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_dim_items:
00122                 setDimItems(attrval_int);
00123                 break;
00124             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_fixed_pos:
00125                 setFixedPos(attrval_int);
00126                 break;
00127             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_hloop:
00128                 setHLoop((attrval_int) ? true : false);
00129                 break;
00130             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_vloop:
00131                 setVLoop((attrval_int) ? true : false);
00132                 break;
00133             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_trans_items:
00134                 setTransItems(attrval_int);
00135                 break;
00136             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_dim_top:
00137                 setDimTop(attrval_int);
00138                 break;
00139             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_dim_bottom:
00140                 setDimBottom(attrval_int);
00141                 break;
00142             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_dim_left:
00143                 setDimLeft(attrval_int);
00144                 break;
00145             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_dim_right:
00146                 setDimRight(attrval_int);
00147                 break;
00148             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_trans_top:
00149                 setTransTop(attrval_int);
00150                 break;
00151             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_trans_bottom:
00152                 setTransBottom(attrval_int);
00153                 break;
00154             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_trans_left:
00155                 setTransLeft(attrval_int);
00156                 break;
00157             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_trans_right:
00158                 setTransRight(attrval_int);
00159                 break;
00160             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_zoomsel_width:
00161                 setZoomSelWidth(attrval_str);
00162                 break;
00163             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_zoomsel_height:
00164                 setZoomSelHeight(attrval_str);
00165                 break;
00166             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_zoomsel_shiftx:
00167                 setZoomSelShiftX(attrval_str);
00168                 break;
00169             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_zoomsel_shifty:
00170                 setZoomSelShiftY(attrval_str);
00171                 break;
00172             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_smooth_scrolling:
00173                 if ((attrval_int & 0xff) == 0x01)
00174                     setSmoothScrolling(MMSSEQUENCEMODE_LINEAR);
00175                 else
00176                 if ((attrval_int & 0xff) == 0x02)
00177                     setSmoothScrolling(MMSSEQUENCEMODE_LOG);
00178                 else
00179                 if ((attrval_int & 0xff) == 0x03)
00180                     setSmoothScrolling(MMSSEQUENCEMODE_LOG_SOFT_START);
00181                 else
00182                 if ((attrval_int & 0xff) == 0x04)
00183                     setSmoothScrolling(MMSSEQUENCEMODE_LOG_SOFT_END);
00184                 else
00185                 if (attrval_int)
00186                     setSmoothScrolling(MMSSEQUENCEMODE_LINEAR);
00187                 else
00188                     setSmoothScrolling(MMSSEQUENCEMODE_NONE);
00189                 break;
00190             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_parent_window:
00191                 setParentWindow(attrval_str);
00192                 break;
00193             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_selimage:
00194                 if (*attrval_str)
00195                     setSelImagePath("");
00196                 else
00197                     setSelImagePath((path)?*path:"");
00198                 setSelImageName(attrval_str);
00199                 break;
00200             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_selimage_path:
00201                 if (*attrval_str)
00202                     setSelImagePath(attrval_str);
00203                 else
00204                     setSelImagePath((path)?*path:"");
00205                 break;
00206             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_selimage_name:
00207                 setSelImageName(attrval_str);
00208                 break;
00209             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_smooth_selection:
00210                 if ((attrval_int & 0xff) == 0x01)
00211                     setSmoothSelection(MMSSEQUENCEMODE_LINEAR);
00212                 else
00213                 if ((attrval_int & 0xff) == 0x02)
00214                     setSmoothSelection(MMSSEQUENCEMODE_LOG);
00215                 else
00216                 if ((attrval_int & 0xff) == 0x03)
00217                     setSmoothSelection(MMSSEQUENCEMODE_LOG_SOFT_START);
00218                 else
00219                 if ((attrval_int & 0xff) == 0x04)
00220                     setSmoothSelection(MMSSEQUENCEMODE_LOG_SOFT_END);
00221                 else
00222                 if (attrval_int)
00223                     setSmoothSelection(MMSSEQUENCEMODE_LINEAR);
00224                 else
00225                     setSmoothSelection(MMSSEQUENCEMODE_NONE);
00226                 break;
00227             case MMSGUI_MENUWIDGET_ATTR::MMSGUI_MENUWIDGET_ATTR_IDS_smooth_delay:
00228                 setSmoothDelay(attrval_int);
00229                 break;
00230             }
00231         }
00232         endTAFFScan
00233     }
00234     else {
00235         unsigned int pl = strlen(prefix->c_str());
00236 
00237         startTAFFScan_WITHOUT_ID
00238         {
00239             // check if attrname has correct prefix
00240             if (pl >= strlen(attrname))
00241                 continue;
00242             if (memcmp(attrname, prefix->c_str(), pl)!=0)
00243                 continue;
00244             attrname = &attrname[pl];
00245 
00246             // special storage for macros
00247             bool attrval_str_valid;
00248             bool int_val_set;
00249             bool byte_val_set;
00250             int  *p_int_val = &attrval_int;
00251 
00252             // okay, correct prefix, check attributes now
00253             if (ISATTRNAME(item_width)) {
00254                 setItemWidth(attrval_str);
00255             }
00256             else
00257             if (ISATTRNAME(item_height)) {
00258                 setItemHeight(attrval_str);
00259             }
00260             else
00261             if (ISATTRNAME(item_hmargin)) {
00262                 setItemHMargin(attrval_int);
00263             }
00264             else
00265             if (ISATTRNAME(item_vmargin)) {
00266                 setItemVMargin(attrval_int);
00267             }
00268             else
00269             if (ISATTRNAME(cols)) {
00270                 setCols(attrval_int);
00271             }
00272             else
00273             if (ISATTRNAME(dim_items)) {
00274                 setDimItems(attrval_int);
00275             }
00276             else
00277             if (ISATTRNAME(fixed_pos)) {
00278                 setFixedPos(attrval_int);
00279             }
00280             else
00281             if (ISATTRNAME(hloop)) {
00282                 setHLoop((attrval_int) ? true : false);
00283             }
00284             else
00285             if (ISATTRNAME(vloop)) {
00286                 setVLoop((attrval_int) ? true : false);
00287             }
00288             else
00289             if (ISATTRNAME(trans_items)) {
00290                 setTransItems(attrval_int);
00291             }
00292             else
00293             if (ISATTRNAME(dim_top)) {
00294                 setDimTop(attrval_int);
00295             }
00296             else
00297             if (ISATTRNAME(dim_bottom)) {
00298                 setDimBottom(attrval_int);
00299             }
00300             else
00301             if (ISATTRNAME(dim_left)) {
00302                 setDimLeft(attrval_int);
00303             }
00304             else
00305             if (ISATTRNAME(dim_right)) {
00306                 setDimRight(attrval_int);
00307             }
00308             else
00309             if (ISATTRNAME(trans_top)) {
00310                 setTransTop(attrval_int);
00311             }
00312             else
00313             if (ISATTRNAME(trans_bottom)) {
00314                 setTransBottom(attrval_int);
00315             }
00316             else
00317             if (ISATTRNAME(trans_left)) {
00318                 setTransLeft(attrval_int);
00319             }
00320             else
00321             if (ISATTRNAME(trans_right)) {
00322                 setTransRight(attrval_int);
00323             }
00324             else
00325             if (ISATTRNAME(zoomsel_width)) {
00326                 setZoomSelWidth(attrval_str);
00327             }
00328             else
00329             if (ISATTRNAME(zoomsel_height)) {
00330                 setZoomSelHeight(attrval_str);
00331             }
00332             else
00333             if (ISATTRNAME(zoomsel_shiftx)) {
00334                 setZoomSelShiftX(attrval_str);
00335             }
00336             else
00337             if (ISATTRNAME(zoomsel_shifty)) {
00338                 setZoomSelShiftY(attrval_str);
00339             }
00340             else
00341             if (ISATTRNAME(smooth_scrolling)) {
00342                 if ((attrval_int & 0xff) == 0x01)
00343                     setSmoothScrolling(MMSSEQUENCEMODE_LINEAR);
00344                 else
00345                 if ((attrval_int & 0xff) == 0x02)
00346                     setSmoothScrolling(MMSSEQUENCEMODE_LOG);
00347                 else
00348                 if ((attrval_int & 0xff) == 0x03)
00349                     setSmoothScrolling(MMSSEQUENCEMODE_LOG_SOFT_START);
00350                 else
00351                 if ((attrval_int & 0xff) == 0x04)
00352                     setSmoothScrolling(MMSSEQUENCEMODE_LOG_SOFT_END);
00353                 else
00354                 if (attrval_int)
00355                     setSmoothScrolling(MMSSEQUENCEMODE_LINEAR);
00356                 else
00357                     setSmoothScrolling(MMSSEQUENCEMODE_NONE);
00358             }
00359             else
00360             if (ISATTRNAME(parent_window)) {
00361                 setParentWindow(attrval_str);
00362             }
00363             else
00364             if (ISATTRNAME(selimage)) {
00365                 if (*attrval_str)
00366                     setSelImagePath("");
00367                 else
00368                     setSelImagePath((path)?*path:"");
00369                 setSelImageName(attrval_str);
00370             }
00371             else
00372             if (ISATTRNAME(selimage_path)) {
00373                 if (*attrval_str)
00374                     setSelImagePath(attrval_str);
00375                 else
00376                     setSelImagePath((path)?*path:"");
00377             }
00378             else
00379             if (ISATTRNAME(selimage_name)) {
00380                 setSelImageName(attrval_str);
00381             }
00382             else
00383             if (ISATTRNAME(smooth_selection)) {
00384                 if ((attrval_int & 0xff) == 0x01)
00385                     setSmoothSelection(MMSSEQUENCEMODE_LINEAR);
00386                 else
00387                 if ((attrval_int & 0xff) == 0x02)
00388                     setSmoothSelection(MMSSEQUENCEMODE_LOG);
00389                 else
00390                 if ((attrval_int & 0xff) == 0x03)
00391                     setSmoothSelection(MMSSEQUENCEMODE_LOG_SOFT_START);
00392                 else
00393                 if ((attrval_int & 0xff) == 0x04)
00394                     setSmoothSelection(MMSSEQUENCEMODE_LOG_SOFT_END);
00395                 else
00396                 if (attrval_int)
00397                     setSmoothSelection(MMSSEQUENCEMODE_LINEAR);
00398                 else
00399                     setSmoothSelection(MMSSEQUENCEMODE_NONE);
00400             }
00401             else
00402             if (ISATTRNAME(smooth_delay)) {
00403                 setSmoothDelay(attrval_int);
00404             }
00405         }
00406         endTAFFScan_WITHOUT_ID
00407     }
00408 
00409     if ((reset_paths)&&(path)&&(*path!="")) {
00410         // set my paths
00411         if (!isSelImagePath())
00412             setSelImagePath(*path);
00413     }
00414 }
00415 
00416 void MMSMenuWidgetClass::duplicateTAFF(MMSTaffFile *tafff) {
00417     if (this->tafff)
00418         delete this->tafff;
00419     this->tafff = tafff->copyCurrentTag();
00420 }
00421 
00422 MMSTaffFile *MMSMenuWidgetClass::getTAFF() {
00423     if (this->tafff)
00424         this->tafff->getFirstTag();
00425     return this->tafff;
00426 }
00427 
00428 void MMSMenuWidgetClass::setClassName(string className) {
00429     this->className = className;
00430 }
00431 
00432 string MMSMenuWidgetClass::getClassName() {
00433     return this->className;
00434 }
00435 
00436 bool MMSMenuWidgetClass::isItemWidth() {
00437     return this->isitemwidth;
00438 }
00439 
00440 void MMSMenuWidgetClass::setItemWidth(string itemwidth) {
00441     this->itemwidth = itemwidth;
00442     this->isitemwidth = true;
00443 }
00444 
00445 void MMSMenuWidgetClass::unsetItemWidth() {
00446     this->isitemwidth = false;
00447 }
00448 
00449 string MMSMenuWidgetClass::getItemWidth() {
00450     return this->itemwidth;
00451 }
00452 
00453 bool MMSMenuWidgetClass::isItemHeight() {
00454     return this->isitemheight;
00455 }
00456 
00457 void MMSMenuWidgetClass::setItemHeight(string itemheight) {
00458     this->itemheight = itemheight;
00459     this->isitemheight = true;
00460 }
00461 
00462 void MMSMenuWidgetClass::unsetItemHeight() {
00463     this->isitemheight = false;
00464 }
00465 
00466 string MMSMenuWidgetClass::getItemHeight() {
00467     return this->itemheight;
00468 }
00469 
00470 bool MMSMenuWidgetClass::isItemHMargin() {
00471     return this->isitemhmargin;
00472 }
00473 
00474 void MMSMenuWidgetClass::setItemHMargin(unsigned int itemhmargin) {
00475     this->itemhmargin = itemhmargin;
00476     this->isitemhmargin = true;
00477 }
00478 
00479 void MMSMenuWidgetClass::unsetItemHMargin() {
00480     this->isitemhmargin = false;
00481 }
00482 
00483 unsigned int MMSMenuWidgetClass::getItemHMargin() {
00484     return this->itemhmargin;
00485 }
00486 
00487 bool MMSMenuWidgetClass::isItemVMargin() {
00488     return this->isitemvmargin;
00489 }
00490 
00491 void MMSMenuWidgetClass::setItemVMargin(unsigned int itemvmargin) {
00492     this->itemvmargin = itemvmargin;
00493     this->isitemvmargin = true;
00494 }
00495 
00496 void MMSMenuWidgetClass::unsetItemVMargin() {
00497     this->isitemvmargin = false;
00498 }
00499 
00500 unsigned int MMSMenuWidgetClass::getItemVMargin() {
00501     return this->itemvmargin;
00502 }
00503 
00504 bool MMSMenuWidgetClass::isCols() {
00505     return this->iscols;
00506 }
00507 
00508 void MMSMenuWidgetClass::setCols(unsigned int cols) {
00509     this->cols = cols;
00510     this->iscols = true;
00511 }
00512 
00513 void MMSMenuWidgetClass::unsetCols() {
00514     this->iscols = false;
00515 }
00516 
00517 unsigned int MMSMenuWidgetClass::getCols() {
00518     return this->cols;
00519 }
00520 
00521 bool MMSMenuWidgetClass::isDimItems() {
00522     return this->isdimitems;
00523 }
00524 
00525 void MMSMenuWidgetClass::setDimItems(unsigned int dimitems) {
00526     this->dimitems = dimitems;
00527     this->isdimitems = true;
00528 }
00529 
00530 void MMSMenuWidgetClass::unsetDimItems() {
00531     this->isdimitems = false;
00532 }
00533 
00534 unsigned int MMSMenuWidgetClass::getDimItems() {
00535     return this->dimitems;
00536 }
00537 
00538 bool MMSMenuWidgetClass::isFixedPos() {
00539     return this->isfixedpos;
00540 }
00541 
00542 void MMSMenuWidgetClass::setFixedPos(int fixedpos) {
00543     this->fixedpos = fixedpos;
00544     this->isfixedpos = true;
00545 }
00546 
00547 void MMSMenuWidgetClass::unsetFixedPos() {
00548     this->isfixedpos = false;
00549 }
00550 
00551 int MMSMenuWidgetClass::getFixedPos() {
00552     return this->fixedpos;
00553 }
00554 
00555 bool MMSMenuWidgetClass::isHLoop() {
00556     return this->ishloop;
00557 }
00558 
00559 void MMSMenuWidgetClass::setHLoop(bool hloop) {
00560     this->hloop = hloop;
00561     this->ishloop = true;
00562 }
00563 
00564 void MMSMenuWidgetClass::unsetHLoop() {
00565     this->ishloop = false;
00566 }
00567 
00568 bool MMSMenuWidgetClass::getHLoop() {
00569     return this->hloop;
00570 }
00571 
00572 bool MMSMenuWidgetClass::isVLoop() {
00573     return this->isvloop;
00574 }
00575 
00576 void MMSMenuWidgetClass::setVLoop(bool vloop) {
00577     this->vloop = vloop;
00578     this->isvloop = true;
00579 }
00580 
00581 void MMSMenuWidgetClass::unsetVLoop() {
00582     this->isvloop = false;
00583 }
00584 
00585 bool MMSMenuWidgetClass::getVLoop() {
00586     return this->vloop;
00587 }
00588 
00589 bool MMSMenuWidgetClass::isTransItems() {
00590     return this->istransitems;
00591 }
00592 
00593 void MMSMenuWidgetClass::setTransItems(unsigned int transitems) {
00594     this->transitems = transitems;
00595     this->istransitems = true;
00596 }
00597 
00598 void MMSMenuWidgetClass::unsetTransItems() {
00599     this->istransitems = false;
00600 }
00601 
00602 unsigned int MMSMenuWidgetClass::getTransItems() {
00603     return this->transitems;
00604 }
00605 
00606 bool MMSMenuWidgetClass::isDimTop() {
00607     return this->isdimtop;
00608 }
00609 
00610 void MMSMenuWidgetClass::setDimTop(unsigned int dimtop) {
00611     this->dimtop = dimtop;
00612     this->isdimtop = true;
00613 }
00614 
00615 void MMSMenuWidgetClass::unsetDimTop() {
00616     this->isdimtop = false;
00617 }
00618 
00619 unsigned int MMSMenuWidgetClass::getDimTop() {
00620     return this->dimtop;
00621 }
00622 
00623 bool MMSMenuWidgetClass::isDimBottom() {
00624     return this->isdimbottom;
00625 }
00626 
00627 void MMSMenuWidgetClass::setDimBottom(unsigned int dimbottom) {
00628     this->dimbottom = dimbottom;
00629     this->isdimbottom = true;
00630 }
00631 
00632 void MMSMenuWidgetClass::unsetDimBottom() {
00633     this->isdimbottom = false;
00634 }
00635 
00636 unsigned int MMSMenuWidgetClass::getDimBottom() {
00637     return this->dimbottom;
00638 }
00639 
00640 bool MMSMenuWidgetClass::isDimLeft() {
00641     return this->isdimleft;
00642 }
00643 
00644 void MMSMenuWidgetClass::setDimLeft(unsigned int dimleft) {
00645     this->dimleft = dimleft;
00646     this->isdimleft = true;
00647 }
00648 
00649 void MMSMenuWidgetClass::unsetDimLeft() {
00650     this->isdimleft = false;
00651 }
00652 
00653 unsigned int MMSMenuWidgetClass::getDimLeft() {
00654     return this->dimleft;
00655 }
00656 
00657 bool MMSMenuWidgetClass::isDimRight() {
00658     return this->isdimright;
00659 }
00660 
00661 void MMSMenuWidgetClass::setDimRight(unsigned int dimright) {
00662     this->dimright = dimright;
00663     this->isdimright = true;
00664 }
00665 
00666 void MMSMenuWidgetClass::unsetDimRight() {
00667     this->isdimright = false;
00668 }
00669 
00670 unsigned int MMSMenuWidgetClass::getDimRight() {
00671     return this->dimright;
00672 }
00673 
00674 bool MMSMenuWidgetClass::isTransTop() {
00675     return this->istranstop;
00676 }
00677 
00678 void MMSMenuWidgetClass::setTransTop(unsigned int transtop) {
00679     this->transtop = transtop;
00680     this->istranstop = true;
00681 }
00682 
00683 void MMSMenuWidgetClass::unsetTransTop() {
00684     this->istranstop = false;
00685 }
00686 
00687 unsigned int MMSMenuWidgetClass::getTransTop() {
00688     return this->transtop;
00689 }
00690 
00691 bool MMSMenuWidgetClass::isTransBottom() {
00692     return this->istransbottom;
00693 }
00694 
00695 void MMSMenuWidgetClass::setTransBottom(unsigned int transbottom) {
00696     this->transbottom = transbottom;
00697     this->istransbottom = true;
00698 }
00699 
00700 void MMSMenuWidgetClass::unsetTransBottom() {
00701     this->istransbottom = false;
00702 }
00703 
00704 unsigned int MMSMenuWidgetClass::getTransBottom() {
00705     return this->transbottom;
00706 }
00707 
00708 bool MMSMenuWidgetClass::isTransLeft() {
00709     return this->istransleft;
00710 }
00711 
00712 void MMSMenuWidgetClass::setTransLeft(unsigned int transleft) {
00713     this->transleft = transleft;
00714     this->istransleft = true;
00715 }
00716 
00717 void MMSMenuWidgetClass::unsetTransLeft() {
00718     this->istransleft = false;
00719 }
00720 
00721 unsigned int MMSMenuWidgetClass::getTransLeft() {
00722     return this->transleft;
00723 }
00724 
00725 bool MMSMenuWidgetClass::isTransRight() {
00726     return this->istransright;
00727 }
00728 
00729 void MMSMenuWidgetClass::setTransRight(unsigned int transright) {
00730     this->transright = transright;
00731     this->istransright = true;
00732 }
00733 
00734 void MMSMenuWidgetClass::unsetTransRight() {
00735     this->istransright = false;
00736 }
00737 
00738 unsigned int MMSMenuWidgetClass::getTransRight() {
00739     return this->transright;
00740 }
00741 
00742 
00743 
00744 bool MMSMenuWidgetClass::isZoomSelWidth() {
00745     return this->iszoomselwidth;
00746 }
00747 
00748 void MMSMenuWidgetClass::setZoomSelWidth(string zoomselwidth) {
00749     this->zoomselwidth = zoomselwidth;
00750     this->iszoomselwidth = true;
00751 }
00752 
00753 void MMSMenuWidgetClass::unsetZoomSelWidth() {
00754     this->iszoomselwidth = false;
00755 }
00756 
00757 string MMSMenuWidgetClass::getZoomSelWidth() {
00758     return this->zoomselwidth;
00759 }
00760 
00761 bool MMSMenuWidgetClass::isZoomSelHeight() {
00762     return this->iszoomselheight;
00763 }
00764 
00765 void MMSMenuWidgetClass::setZoomSelHeight(string zoomselheight) {
00766     this->zoomselheight = zoomselheight;
00767     this->iszoomselheight = true;
00768 }
00769 
00770 void MMSMenuWidgetClass::unsetZoomSelHeight() {
00771     this->iszoomselheight = false;
00772 }
00773 
00774 string MMSMenuWidgetClass::getZoomSelHeight() {
00775     return this->zoomselheight;
00776 }
00777 
00778 bool MMSMenuWidgetClass::isZoomSelShiftX() {
00779     return this->iszoomselshiftx;
00780 }
00781 
00782 void MMSMenuWidgetClass::setZoomSelShiftX(string zoomselshiftx) {
00783     this->zoomselshiftx = zoomselshiftx;
00784     this->iszoomselshiftx = true;
00785 }
00786 
00787 void MMSMenuWidgetClass::unsetZoomSelShiftX() {
00788     this->iszoomselshiftx = false;
00789 }
00790 
00791 string MMSMenuWidgetClass::getZoomSelShiftX() {
00792     return this->zoomselshiftx;
00793 }
00794 
00795 bool MMSMenuWidgetClass::isZoomSelShiftY() {
00796     return this->iszoomselshifty;
00797 }
00798 
00799 void MMSMenuWidgetClass::setZoomSelShiftY(string zoomselshifty) {
00800     this->zoomselshifty = zoomselshifty;
00801     this->iszoomselshifty = true;
00802 }
00803 
00804 void MMSMenuWidgetClass::unsetZoomSelShiftY() {
00805     this->iszoomselshifty = false;
00806 }
00807 
00808 string MMSMenuWidgetClass::getZoomSelShiftY() {
00809     return this->zoomselshifty;
00810 }
00811 
00812 bool MMSMenuWidgetClass::isSmoothScrolling() {
00813     return this->issmoothscrolling;
00814 }
00815 
00816 void MMSMenuWidgetClass::setSmoothScrolling(MMSSEQUENCEMODE smoothscrolling) {
00817     this->smoothscrolling = smoothscrolling;
00818     this->issmoothscrolling = true;
00819 }
00820 
00821 void MMSMenuWidgetClass::unsetSmoothScrolling() {
00822     this->issmoothscrolling = false;
00823 }
00824 
00825 MMSSEQUENCEMODE MMSMenuWidgetClass::getSmoothScrolling() {
00826     return this->smoothscrolling;
00827 }
00828 
00829 bool MMSMenuWidgetClass::isParentWindow() {
00830     return this->isparentwindow;
00831 }
00832 
00833 void MMSMenuWidgetClass::setParentWindow(string parentwindow) {
00834     this->parentwindow = parentwindow;
00835     this->isparentwindow = true;
00836 }
00837 
00838 void MMSMenuWidgetClass::unsetParentWindow() {
00839     this->isparentwindow = false;
00840 }
00841 
00842 string MMSMenuWidgetClass::getParentWindow() {
00843     return this->parentwindow;
00844 }
00845 
00846 
00847 
00848 bool MMSMenuWidgetClass::isSelImagePath() {
00849     return this->isselimagepath;
00850 }
00851 
00852 void MMSMenuWidgetClass::setSelImagePath(string selimagepath) {
00853     this->selimagepath = selimagepath;
00854     this->isselimagepath = true;
00855 }
00856 
00857 void MMSMenuWidgetClass::unsetSelImagePath() {
00858     this->isselimagepath = false;
00859 }
00860 
00861 string MMSMenuWidgetClass::getSelImagePath() {
00862     return this->selimagepath;
00863 }
00864 
00865 bool MMSMenuWidgetClass::isSelImageName() {
00866     return this->isselimagename;
00867 }
00868 
00869 void MMSMenuWidgetClass::setSelImageName(string selimagename) {
00870     this->selimagename = selimagename;
00871     this->isselimagename = true;
00872 }
00873 
00874 void MMSMenuWidgetClass::unsetSelImageName() {
00875     this->isselimagename = false;
00876 }
00877 
00878 string MMSMenuWidgetClass::getSelImageName() {
00879     return this->selimagename;
00880 }
00881 
00882 bool MMSMenuWidgetClass::isSmoothSelection() {
00883     return this->issmoothselection;
00884 }
00885 
00886 void MMSMenuWidgetClass::setSmoothSelection(MMSSEQUENCEMODE smoothselection) {
00887     this->smoothselection = smoothselection;
00888     this->issmoothselection = true;
00889 }
00890 
00891 void MMSMenuWidgetClass::unsetSmoothSelection() {
00892     this->issmoothselection = false;
00893 }
00894 
00895 MMSSEQUENCEMODE MMSMenuWidgetClass::getSmoothSelection() {
00896     return this->smoothselection;
00897 }
00898 
00899 
00900 bool MMSMenuWidgetClass::isSmoothDelay() {
00901     return this->issmoothdelay;
00902 }
00903 
00904 void MMSMenuWidgetClass::setSmoothDelay(unsigned int smoothdelay) {
00905     this->smoothdelay = smoothdelay;
00906     this->issmoothdelay = true;
00907 }
00908 
00909 void MMSMenuWidgetClass::unsetSmoothDelay() {
00910     this->issmoothdelay = false;
00911 }
00912 
00913 unsigned int MMSMenuWidgetClass::getSmoothDelay() {
00914     return this->smoothdelay;
00915 }
00916 
00917