protected function startPageFlip (event:MouseEvent=null, attemptHover:Boolean=false):void {
                          
                          
                          var side:uint = this.getCurrentSide();
                          var oldPage:Page = this.getPage(this._currentPage+this.lastFlippedSide, false);
                          
                          // no pageflips before creationComplete:
                          if (!this.created){
                                  return;
                          }
                          // if the @ax-lib-flex-book-com-rubenswieringa-book-Book was clicked and gotoPage is active then attempt to abort gotoPage:
                          if (this.autoFlipActive && !this.tearActive && this.pageCorner.x >= 0 && this.pageCorner.x <= this.width/2 && event != null){
                                  this.cancelGotoPage(false);
                                  return;
                          }
                          // stop if the clicked SuperViewStack does not show any Pages:
                          if (((!this.pageL.visible && side == Page.LEFT) || (!this.pageR.visible && side == Page.RIGHT)) && this._status != @fileEvent.PAGEFLIP_STARTED && this._status != @fileEvent.PAGEFLIP_ENDING && this._status != @fileEvent.HOVER_STARTED && this._status != @fileEvent.HOVER_ENDING){
                                  return;
                          }
                          // stop if none of the pagecorners are hit:
                          if (!this.isPageCornerHit() && (!this.sideFlip || !this.isPageSideHit()) && !this.autoFlipActive){
                                  return;
                          }
                          // don't flip if Page isn't allowed to:
                          if (Page(this._pages.getItemAt(this._currentPage+side)).lock){
                                  this.autoFlipActive = false; // shut-down auto-pageflip if active
                                  return;
                          }
                          // stop if a page corner is flipping back into position
                          if ((this._status == @fileEvent.PAGEFLIP_ENDING || this._status == @fileEvent.HOVER_ENDING) && !this.autoFlipActive && !this.lastFlipSucceeded){
                                  // switch back to flipping mode if the same page corner was picked up:
                                  if (this.lastFlippedCorner.equals(this.getCurrentCorner()) && this.sideFlipActive == this.isPageSideHit()){
                                          this.stage.addEventListener(MouseEvent.MOUSE_UP, this.endPageFlip);
                                          var newStatus:String = (this.hoverActive) ? @fileEvent.HOVER_STARTED : @fileEvent.PAGEFLIP_STARTED;
                                          this.setStatus(newStatus, true, oldPage);
                                  }
                                  return;
                          }
                          // stop if the @ax-lib-flex-book-com-rubenswieringa-book-Book is not inactive and not hovering:
                          if (this._status != @fileEvent.NOT_FLIPPING && !this.hoverActive){
                                  return;
                          }
                          // if the page is hovering and an actual pageflip should begin:
                          if (this.hoverActive && this._status == @fileEvent.HOVER_STARTED){
                                  this.hoverActive = false;
                                  this.setLastFlippedTime(); // if necessary, remember time at which pageflip started
                                  this.setStatus(@fileEvent.PAGEFLIP_STARTED, true, oldPage);
                                  return;
                          }
                          
                          // throw an Error if the Page in question has no flipside:
                          // in the above stated situation the right-hand side Page typically does not have a flipside, and consequently its index will be equal to the total amount of pages (minus one). Also note that any left-hand side Page will always have a flipside, because the first Page in a @ax-lib-flex-book-com-rubenswieringa-book-Book is always on the right-hand side.
                          if (this._currentPage+1 == this._pages.length-1 && side == Page.RIGHT){
                                  throw new @fileError(@fileError.NO_FLIPSIDE);
                          }
                          
                          // set hover-flag:
                          this.hoverActive = attemptHover;
                          
                          // set direction markers and position the render:
                          if ( this.autoFlipActive && !this.tearActive)        this.lastFlippedCorner = new Point(side, 1);
                          if ( this.autoFlipActive &&  this.tearActive)        this.lastFlippedCorner = new Point(side, (this.tearFromTop) ? 0 : 1);
                          if (!this.autoFlipActive)                                                this.lastFlippedCorner = this.getCurrentCorner();
                          this.lastFlippedSide                =  this.lastFlippedCorner.x;
                          this.lastFlippedDirection        = (side == Page.LEFT) ? -1 : 1;
                          this.sideFlipActive                        = (!this.tearActive && this.sideFlip && this.isPageSideHit());
                          this.render.x = this.lastFlippedSide * this.width/2;
                          
                          // specify front and flipside indexes:
                          var frontIndex:uint        = this._currentPage + this.lastFlippedSide;
                          var backIndex:uint        = this._currentPage + this.lastFlippedSide + this.lastFlippedDirection;
                          // save bitmapData:
                          this.saveBitmapData(Page(this._pages.getItemAt(frontIndex)), Page(this._pages.getItemAt(backIndex)));
                          
                          // select pages in SuperViewStacks:
                          if (this.lastFlippedSide == Page.LEFT){ // if left-hand page was flipped
                                  this.pageL.visible = !this.isFirstPage(this._currentPage+1-2);
                                  if (this.pageL.visible){
                                          this.pageL.selectedChild = Page(this._pages.getItemAt(this._currentPage-2));
                                  }else{
                                  }
                          }
                          if (this.lastFlippedSide == Page.RIGHT){ // if right-hand page was flipped
                                  this.pageR.visible = !this.isLastPage(this._currentPage+2);
                                  if (this.pageR.visible){
                                          this.pageR.selectedChild = Page(this._pages.getItemAt(this._currentPage+1+2));
                                  }
                          }
                          
                          // set page corner markers:
                          this.pageCorner = new Point(this.lastFlippedCorner.x*this.width/2, this.lastFlippedCorner.y*this.height);
                          if (this.autoFlipActive){
                                  this.pageCornerTarget = this.pageCorner.clone();
                          }
                          
                          // if necessary, remember time at which pageflip started:
                          this.setLastFlippedTime();
                          
                          
                          // set status:
                          this.setStatus((this.hoverActive) ? @fileEvent.HOVER_STARTED : @fileEvent.PAGEFLIP_STARTED, false); // false = dispatch Event later
                          
                          // add listeners:
                          this.dragPageCorner();
                          this.addEventListener(Event.ENTER_FRAME, this.dragPageCorner);
                          this.stage.addEventListener(MouseEvent.MOUSE_UP, this.endPageFlip);
                          
                          // dispatch event:
                          var page:Page = Page(this._pages.getItemAt(this._currentPage+this.lastFlippedSide));
                          if (this.hoverActive){
                                  this.dispatchEvent(new @fileEvent(@fileEvent.HOVER_STARTED, this, page));
                          }else{
                                  this.dispatchEvent(new @fileEvent(@fileEvent.PAGEFLIP_STARTED, this, page));
                          }
                          
                  }