C++ (Cpp) getSplitPoint Examples

Example #1

File: jhwr_japanese.cpp Project: chenhbzl/BooxApp

bool jHWRJapanese::recognizeMultipleChars(HZ_INT16 * points, long length, QStringList & result)
{
    result.clear();
    HZ_WORD * code_array = new HZ_WORD[candidates_num_ + 20];
    code_array[candidates_num_] = 0;

#ifdef BUILD_FOR_ARM
    short split_points[1024 * 2] = {0};
    jtSplitCharBox split_char_boxes[200] = {0};
    memset(split_char_boxes, 0, sizeof(jtSplitCharBox) * 200);

    int split_size = jtSplitChar_SplitPointArray(points, length/2, (jtSplitCharBox *)split_char_boxes, 200);
    qDebug("Split point array successfully:%d", split_size);

    for(int i = 0; i < split_size; i++)
    {
        memset(code_array, 0, sizeof(code_array));
        memset(split_points, 0, sizeof(split_points));

        int start = split_char_boxes[i].nPos * 2;
        int end = (i == split_size - 1) ? length : (split_char_boxes[i + 1].nPos) * 2;

        getSplitPoint(points, start, (end - start), split_points, 1024 * 2);
        int num_result = HZCharacterRecognize(split_points, (unsigned short*)code_array);
        qDebug("Recognize Done:%d", num_result);

        for (int idx_result = 0; idx_result < num_result; idx_result++)
        {
            if (idx_result < result.size())
            {
                result[idx_result].push_back(QChar(code_array[idx_result]));
            }
            else
            {
                result.push_back(QChar(code_array[idx_result]));
            }
        }
    }
#else
    result.push_back(QString(QChar(0x82A6)));
    result.push_back(QString(QChar(0x82A7)));
    result.push_back(QString(QChar(0x82A8)));
    result.push_back(QString(QChar(0x82A9)));
    result.push_back(QString(QChar(0x82AA)));
    result.push_back(QString(QChar(0x82AB)));
    result.push_back(QString(QChar(0x82AC)));
    result.push_back(QString(QChar(0x82AD)));
    result.push_back(QString(QChar(0x82AE)));
    result.push_back(QString(QChar(0x82AF)));
#endif
    delete []code_array;
    return true;
}

Example #2

File: guiSplitContainer.cpp Project: Dwarf-King/OmniEngine.Net

void GuiSplitContainer::onMouseUp( const GuiEvent &event )
{
   // If we've been dragging, we need to update the fixed panel extent.  
   // NOTE : This should ONLY ever happen in this function.  the Fixed panel
   // is to REMAIN FIXED unless the user changes it.
   if ( mDragging )
   {
      Point2I newSplitPoint = getSplitPoint();

      // Update Fixed Panel Extent
      if ( mFixedPanel == FirstPanel )
         mFixedPanelSize = ( mOrientation == Horizontal ) ? newSplitPoint.y : newSplitPoint.x;
      else
         mFixedPanelSize = ( mOrientation == Horizontal ) ? getExtent().y - newSplitPoint.y : getExtent().x - newSplitPoint.x;

      setUpdateLayout();
   }

   mDragging = false;
   mouseUnlock();
}

Example #3

File: LcdDisplay.cpp Project: Drent001/Arduino

void LcdDisplay::print(char const *text)
{
  lcd->clear();

  if (_screenWidth == 0 || _screenHeight == 0)
  {
    lcd->setCursor(0, 0);
    lcd->print("Use Initialize()");
    return; //No CenterText; width unknown
  }
    
  int row = 0;
  char *currentText = (char *)&text[0];
  int textLength = strlen(currentText);
  
  while (textLength > 0 && row < _screenWidth)
  {
    int splitPoint = getSplitPoint(currentText);
    char *lineText = clone(currentText, splitPoint);
    lcd->setCursor(getCenterStartPoint(lineText), row);
    lcd->print(lineText);
    delete(lineText);
    
    if (splitPoint < textLength)
    {
      currentText = &currentText[splitPoint + 1];
      textLength = strlen(currentText);
    }
    else
    {
      textLength = 0;
    }
    row++;
  }
  char *rowText;  
}

Example #4

File: guiSplitContainer.cpp Project: Dwarf-King/OmniEngine.Net

bool GuiSplitContainer::layoutControls( RectI &clientRect )
{
   if ( size() < 2 )
      return false;

   GuiContainer *panelOne = dynamic_cast<GuiContainer*>( at(0) );
   GuiContainer *panelTwo = dynamic_cast<GuiContainer*>( at(1) );

   // 
   AssertFatal( panelOne && panelTwo, "GuiSplitContainer::layoutControl - Missing/Invalid Subordinate Controls! Split contained controls must derive from GuiContainer!" );

   RectI panelOneRect = RectI( clientRect.point, Point2I( 0, 0 ) );
   RectI panelTwoRect;
   RectI splitRect;

   solvePanelConstraints( getSplitPoint(), panelOne, panelTwo, clientRect );

   switch( mOrientation )
   {
   case Horizontal:
      panelOneRect.extent = Point2I( clientRect.extent.x, getSplitPoint().y );
      panelTwoRect = panelOneRect;
      panelTwoRect.intersect( clientRect );
      panelTwoRect.point.y = panelOneRect.extent.y;
      panelTwoRect.extent.y = clientRect.extent.y - panelOneRect.extent.y;

      // Generate new Splitter Rectangle
      splitRect = panelTwoRect;
      splitRect.extent.y = 0;
      splitRect.inset( 0, -mSplitterSize );

      panelOneRect.extent.y -= mSplitterSize;
      panelTwoRect.point.y += mSplitterSize;
      panelTwoRect.extent.y -= mSplitterSize;

      break;

   case Vertical:
      panelOneRect.extent = Point2I( getSplitPoint().x, clientRect.extent.y );
      panelTwoRect = panelOneRect;
      panelTwoRect.intersect( clientRect );
      panelTwoRect.point.x = panelOneRect.extent.x;
      panelTwoRect.extent.x = clientRect.extent.x - panelOneRect.extent.x;

      // Generate new Splitter Rectangle
      splitRect = panelTwoRect;
      splitRect.extent.x = 0;
      splitRect.inset( -mSplitterSize, 0 );

      panelOneRect.extent.x -= mSplitterSize;
      panelTwoRect.point.x += mSplitterSize;
      panelTwoRect.extent.x -= mSplitterSize;

      break;
   }

   // Update Split Rect
   mSplitRect = splitRect;

   // Dock Appropriately
   if( !( mFixedPanel == FirstPanel && !panelOne->isVisible() ) )
      dockControl( panelOne, panelOne->getDocking(), panelOneRect );
   if( !( mFixedPanel == FirstPanel && !panelTwo->isVisible() ) )
      dockControl( panelTwo, panelOne->getDocking(), panelTwoRect );   

   // 
   return false;
}