Exemple #1
0
void setProperty(Tree t, Tree key, Tree val)
{
  CTree* pl = t->attribut();

  if(pl)
    t->attribut(updateKey(pl, key, val));
  else
    t->attribut(updateKey(nil, key, val));
}
Exemple #2
0
static void
gridChangeNotify (const char        *optionName,
                  BananaType        optionType,
                  const BananaValue *optionValue,
                  int               screenNum)
{
	GRID_DISPLAY (&display);

	if (strcasecmp (optionName, "put_center_key") == 0)
		updateKey (optionValue->s, &gd->put_center_key);

	else if (strcasecmp (optionName, "put_left_key") == 0)
		updateKey (optionValue->s, &gd->put_left_key);

	else if (strcasecmp (optionName, "put_right_key") == 0)
		updateKey (optionValue->s, &gd->put_right_key);

	else if (strcasecmp (optionName, "put_top_key") == 0)
		updateKey (optionValue->s, &gd->put_top_key);

	else if (strcasecmp (optionName, "put_bottom_key") == 0)
		updateKey (optionValue->s, &gd->put_bottom_key);

	else if (strcasecmp (optionName, "put_topleft_key") == 0)
		updateKey (optionValue->s, &gd->put_topleft_key);

	else if (strcasecmp (optionName, "put_topright_key") == 0)
		updateKey (optionValue->s, &gd->put_topright_key);

	else if (strcasecmp (optionName, "put_bottomleft_key") == 0)
		updateKey (optionValue->s, &gd->put_bottomleft_key);

	else if (strcasecmp (optionName, "put_bottomright_key") == 0)
		updateKey (optionValue->s, &gd->put_bottomright_key);
}
Exemple #3
0
void keyTimer(int tid){
	static int lastKey=0;
	short key;
	int i;
	int down,up;
	watch("lastkey",lastKey);
	down=up=0;
	//for(i=0;i<8;i++)
	//{
	//	if (MYKEYDOWN(keyList[i])) {
	//		updateKey(keyList[i],KEY_DOWN);
	//		lastKey=keyList[i];
	//		break;
	//	}
	//	if (MYKEYUP(keyList[i])&&keyList[i]==lastKey) {
	//		updateKey(keyList[i],KEY_UP);
	//		break;
	//	}

	//}

	for(i=0;i<8;i++)
	{
		if (lastKey==0) {
			if(MYKEYDOWN(keyList[i])) {
				lastKey=keyList[i];
				updateKey(lastKey,KEY_DOWN);
				break;
			}
		}
		else {
			if (lastKey==keyList[i]) {
				if (MYKEYDOWN(lastKey)) {
					lastKey=keyList[i];
					updateKey(lastKey,KEY_DOWN);
					break;
				}
				if (MYKEYUP(lastKey)) {
					lastKey=0;
					updateKey(keyList[i],KEY_UP);
					break;
				}
			}
			else {
				if (MYKEYDOWN(keyList[i])) {
					lastKey=keyList[i];
					updateKey(lastKey,KEY_DOWN);
					break;
				}
			}
		}
	}
}
Exemple #4
0
static Tree updateKey (Tree pl, Tree key, Tree val)
{
    if (isNil(pl))                  return cons ( cons(key,val), nil );
    if (left(hd(pl)) == key)        return cons ( cons(key,val), tl(pl) );
    if (isBefore(left(hd(pl)),key)) return cons ( hd(pl), updateKey( tl(pl), key, val ));
    return cons(cons(key,val), pl);
}
Exemple #5
0
// place un item dans un folder. Remplace eventuellement l'élément de même nom.
Tree putFolder(Tree folder, Tree item)
{
    Tree    label, content;
    
    if ( ! isUiFolder(folder, label, content)) { fprintf(stderr, "ERROR in addFolder : not a folder\n"); }
    return uiFolder(label, updateKey(content, uiLabel(item), item));
}
Exemple #6
0
static void
opacifyChangeNotify (const char        *optionName,
                     BananaType        optionType,
                     const BananaValue *optionValue,
                     int               screenNum)
{
	OPACIFY_DISPLAY (&display);

	if (strcasecmp (optionName, "toggle_key") == 0)
		updateKey (optionValue->s, &od->toggle_key);

	else if (strcasecmp (optionName, "init_toggle") == 0)
		od->toggle = optionValue->b;

	else if (strcasecmp (optionName, "window_match") == 0)
	{
		CompScreen *s = getScreenFromScreenNum (screenNum);
		OPACIFY_SCREEN (s);

		matchFini (&os->window_match);
		matchInit (&os->window_match);
		matchAddFromString (&os->window_match, optionValue->s);
		matchUpdate (&os->window_match);
	}
}
Exemple #7
0
 void ParseContext::patternUpdate( const std::string& pattern , InputError::Action action) {
     const char * c_pattern = pattern.c_str();
     for (const auto& pair : m_errorContexts) {
         const std::string& key = pair.first;
         if (util_fnmatch( c_pattern , key.c_str()) == 0)
             updateKey( key , action );
      }
 }
void LinearKeyPad_scan_from_to( Key *keys , UINT8 fromIndex , UINT8 toIndex )
{
	UINT8 i;
	for( i = fromIndex ; i <= toIndex ; i++)
	{
		readKeyPadPort();
		updateKey( &keys[i] , i );
	}
}
EncryptioNgSimliteDecryptor::EncryptioNgSimliteDecryptor(const Account &account, EncryptionProvider *provider, QObject *parent) :
		Decryptor(provider, parent), MyAccount(account)
{
	connect(KeysManager::instance(), SIGNAL(keyAdded(Key)), this, SLOT(keyUpdated(Key)));
	connect(KeysManager::instance(), SIGNAL(keyUpdated(Key)), this, SLOT(keyUpdated(Key)));
	connect(KeysManager::instance(), SIGNAL(keyRemoved(Key)), this, SLOT(keyUpdated(Key)));

	updateKey();
}
void CLexiconKeyChooser::setKey(CSwordKey* key) {
    if (!(m_key = dynamic_cast<CSwordLDKey*>(key))) {
        return;
    }

    updateKey(key);

    //   qWarning("setKey end");
    emit keyChanged( m_key);
}
Exemple #11
0
ParabolaPointer::RenderState::ParabolaRenderItem::ParabolaRenderItem(const glm::vec3& color, float alpha, float width,
                                                                     bool isVisibleInSecondaryCamera, bool drawInFront, bool enabled) :
    _isVisibleInSecondaryCamera(isVisibleInSecondaryCamera), _drawInFront(drawInFront), _enabled(enabled)
{
    _uniformBuffer->resize(sizeof(ParabolaData));
    setColor(color);
    setAlpha(alpha);
    setWidth(width);
    updateKey();
}
Exemple #12
0
//
// insert - 将一个索引的item装入Node里面
// 
bool BPlusNode::insert(const KeyPtr key, const RID& rid)
{
	int i = -1;
	KeyPtr prev = nullptr, curr = nullptr;
	// 从后往前扫描
	for (i = size_ - 1; i >= 0; i--)
	{
		prev = curr;
		curr = keyAt(i);
		if (keyComp(key, curr) > 0) break;
		rids_[i + 1] = rids_[i];
		updateKey(i + 1, curr);
	}
	rids_[i + 1] = rid;
	updateKey(i + 1, key);
	size_++;
	setSize(size_);
	page_.setDirty();
	return true;
}
Exemple #13
0
static void
mateChangeNotify (const char        *optionName,
                  BananaType        optionType,
                  const BananaValue *optionValue,
                  int               screenNum)
{
	if (strcasecmp (optionName, "main_menu_key") == 0)
		updateKey (optionValue->s, &main_menu_key);

	else if (strcasecmp (optionName, "run_key") == 0)
		updateKey (optionValue->s, &run_key);

	else if (strcasecmp (optionName, "run_command_screenshot_key") == 0)
		updateKey (optionValue->s, &run_command_screenshot_key);

	else if (strcasecmp (optionName, "run_command_window_screenshot_key") == 0)
		updateKey (optionValue->s, &run_command_screenshot_key);

	else if (strcasecmp (optionName, "run_command_terminal_key") == 0)
		updateKey (optionValue->s, &run_command_terminal_key);
}
void JoystickController::update()
{
    if(!m_joystickController)
        return;

    //SDL_PumpEvents();
    SDL_JoystickUpdate();

    updateKey(keys.jump, kmap.jump);
    updateKey(keys.alt_jump, kmap.jump_alt);

    updateKey(keys.run, kmap.run);
    updateKey(keys.alt_run, kmap.run_alt);

    updateKey(keys.right, kmap.right);
    updateKey(keys.left, kmap.left);
    updateKey(keys.up, kmap.up);
    updateKey(keys.down, kmap.down);

    updateKey(keys.drop, kmap.drop);
    updateKey(keys.start, kmap.start);
}
Exemple #15
0
    void ParseContext::update(const std::string& keyString , InputError::Action action) {
        std::vector<std::string> keys;
        boost::split( keys , keyString , boost::is_any_of(":|"));
        for (const auto& input_key : keys) {
            std::vector<std::string> matching_keys;
            size_t wildcard_pos = input_key.find("*");

            if (wildcard_pos == std::string::npos) {
                if (hasKey( input_key ))
                    updateKey( input_key , action );
            } else
                patternUpdate( input_key , action );

        }
    }
Exemple #16
0
// press all supported keys 
// text is a string which contains the key identifiers eg. "KEY_CTRL KEY_C" for Ctrl-C
void setKeyValues(char* text)
{
  char tmptxt[MAX_KEYSTRING_LEN];   // for parsing keystrings
  char * acttoken;
  int modifiers=0;

  strcpy(tmptxt, text); 
  acttoken = strtok(tmptxt," ");

  while (acttoken)
  {
    int kc=getKeycode(acttoken);
    if (kc) updateKey(kc);
    acttoken = strtok(NULL," ");
  }
}
Exemple #17
0
KeyInput::KeyInput(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::KeyInput),
    currentKey(0), currentFlags(0)
{
    ui->setupUi(this);
    connect(this, &KeyInput::accepted, this, &KeyInput::emitKeyAdded);

    filter = new KeyFilter;
    connect(filter, &KeyFilter::keyPress, [this](quint32 key, quint32 mod) {
            currentKey = key;
            currentFlags = mod;
            updateKey();
        });
    qApp->installEventFilter(filter);
}
void LinearKeyPad_scan(  )
{
	UINT8 i = 0;


#ifdef __INPUT_SIMULATION__
	getSimulatedInput();
#else
	readKeyPadPort();
#endif

	for( i = 0; i < MAX_KEYS ; i++)
	{
		updateKey( &keys[i] , i );
	}



}
void EncryptioNgSimliteDecryptor::keyUpdated(const Key &key)
{
	if (key.keyContact() == MyAccount.accountContact() && key.keyType() == "simlite_private")
		updateKey();
}
Exemple #20
0
 void ParseContext::update(InputError::Action action) {
     for (const auto& pair : m_errorContexts) {
         const std::string& key = pair.first;
         updateKey( key , action );
      }
 }
/** Refreshes the content. */
void CBookKeyChooser::refreshContent() {
    if (m_key) {
        updateKey( m_key ); //refresh with current key
    }
}
/** Sets another module to this keychooser */
void CBookKeyChooser::setModules(const QList<CSwordModuleInfo*>& modules, const bool refresh) {
    m_modules.clear();

    //   for (modules.first(); modules.current(); modules.next()) {
    QList<CSwordModuleInfo*>::const_iterator end_it = modules.end();
    for (QList<CSwordModuleInfo*>::const_iterator it(modules.begin()); it != end_it; ++it) {
        if ( (*it)->type() == CSwordModuleInfo::GenericBook ) {
            if (CSwordBookModuleInfo* book = dynamic_cast<CSwordBookModuleInfo*>(*it)) {
                m_modules.append(book);
            }
        }
    }

    //refresh the number of combos
    if (refresh && m_modules.count() && m_key) {
        if (!m_layout) {
            m_layout = new QHBoxLayout(this);
            m_layout->setSpacing(0);
            m_layout->setContentsMargins(0, 0, 0, 0);
        }

        qDeleteAll(m_chooserWidgets);
        m_chooserWidgets.clear();

        for (int i = 0; i < m_modules.first()->depth(); ++i) {
            // Create an empty keychooser, don't handle next/prev signals
            CKeyChooserWidget* w = new CKeyChooserWidget(0, false, this);
            m_chooserWidgets.append( w );

            //don't allow a too high width, try to keep as narrow as possible
            //to aid users with smaller screen resolutions
            int totalWidth = 200; //only 1 level
            if (m_modules.first()->depth() > 1) {
                if (m_modules.first()->depth() > 3)
                    totalWidth = 400; //4+ levels
                else
                    totalWidth = 300; //2-3 levels
            }

            int maxWidth = (int) ((float) totalWidth / (float) m_modules.first()->depth());

            w->comboBox()->setMaximumWidth(maxWidth);
            w->comboBox()->setCurrentIndex(0);

            connect(w, SIGNAL(changed(int)), SLOT(keyChooserChanged(int)));
            connect(w, SIGNAL(focusOut(int)), SLOT(keyChooserChanged(int)));

            m_layout->addWidget(w);
            boxes[w] = i;

            w->show();
        }

        //set the tab order of the key chooser widgets

        CKeyChooserWidget* chooser = 0;
        CKeyChooserWidget* chooser_prev = 0;
        const int count = m_chooserWidgets.count();
        for (int i = 0; i < count; ++i) {
            chooser = m_chooserWidgets.at(i);
            Q_ASSERT(chooser);

            if (chooser && chooser_prev) {
                QWidget::setTabOrder(chooser_prev, chooser);
            }

            chooser_prev = chooser;
        }
        QWidget::setTabOrder(chooser, 0);

        updateKey(m_key);
        adjustFont(); // only when refresh is set.
    }
}
Exemple #23
0
static void
colorFilterChangeNotify (const char        *optionName,
                         BananaType        optionType,
                         const BananaValue *optionValue,
                         int               screenNum)
{
	FILTER_DISPLAY (&display);

	if (strcasecmp (optionName, "toggle_window_key") == 0)
		updateKey (optionValue->s, &cfd->toggle_window_key);

	else if (strcasecmp (optionName, "toggle_screen_key") == 0)
		updateKey (optionValue->s, &cfd->toggle_screen_key);

	else if (strcasecmp (optionName, "switch_filter_key") == 0)
		updateKey (optionValue->s, &cfd->switch_filter_key);

	else if (strcasecmp (optionName, "filter_match") == 0)
	{
		CompWindow *w;
		CompScreen *s = getScreenFromScreenNum (screenNum);

		FILTER_SCREEN (s);

		//Re-check every window against new match settings
		for (w = s->windows; w; w = w->next)
		{
			FILTER_WINDOW (w);

			if (matchEval (&cfs->filter_match, w) &&
			    cfs->isFiltered && !cfw->isFiltered)
			{
				colorFilterToggleWindow (w);
			}
		}
	}

	else if (strcasecmp (optionName, "exclude_match") == 0)
	{
		CompWindow *w;
		CompScreen *s = getScreenFromScreenNum (screenNum);

		FILTER_SCREEN (s);

		// Re-check every window against new match settings
		for (w = s->windows; w; w = w->next)
		{
			Bool isExcluded;

			FILTER_WINDOW (w);

			isExcluded = matchEval (&cfs->exclude_match, w);

			if (isExcluded && cfw->isFiltered)
				colorFilterToggleWindow (w);
			else if (!isExcluded && cfs->isFiltered && !cfw->isFiltered)
				colorFilterToggleWindow (w);
		}
	}

	else if (strcasecmp (optionName, "filters") == 0)
	{
		CompScreen *s = getScreenFromScreenNum (screenNum);

		FILTER_SCREEN (s);

		/* Just set the filtersLoaded boolean to FALSE, unloadFilters will be
		 * called in loadFilters */

		cfs->filtersLoaded = FALSE;
	}

	else if (strcasecmp (optionName, "filter_decorations") == 0)
	{
		CompScreen *s = getScreenFromScreenNum (screenNum);

		damageScreen (s);
	}
}
void LinearKeyPad_updateKey( Key *key , UINT8 keyIndex )
{
	readKeyPadPort();
	updateKey( key , keyIndex);

}	
Exemple #25
0
static void
groupChangeNotify (const char        *optionName,
                   BananaType        optionType,
                   const BananaValue *optionValue,
                   int               screenNum)
{
    GROUP_DISPLAY (&display);

    if (strcasecmp (optionName, "window_match") == 0)
    {
        CompScreen *s = getScreenFromScreenNum (screenNum);
        GROUP_SCREEN (s);

        matchFini (&gs->window_match);
        matchInit (&gs->window_match);
        matchAddFromString (&gs->window_match, optionValue->s);
        matchUpdate (&gs->window_match);
    }
    else if (strcasecmp (optionName, "tab_base_color") == 0 ||
             strcasecmp (optionName, "tab_highlight_color") == 0 ||
             strcasecmp (optionName, "tab_border_color") == 0 ||
             strcasecmp (optionName, "tab_style") == 0 ||
             strcasecmp (optionName, "border_radius") == 0 ||
             strcasecmp (optionName, "border_width") == 0)
    {
        GroupSelection *group;

        CompScreen *s = getScreenFromScreenNum (screenNum);
        GROUP_SCREEN (s);

        for (group = gs->groups; group; group = group->next)
            if (group->tabBar)
                groupRenderTabBarBackground (group);
    }
    else if (strcasecmp (optionName, "tabbar_font_size") == 0 ||
             strcasecmp (optionName, "tabbar_font_color") == 0)
    {
        GroupSelection *group;

        CompScreen *s = getScreenFromScreenNum (screenNum);
        GROUP_SCREEN (s);

        for (group = gs->groups; group; group = group->next)
            groupRenderWindowTitle (group);
    }
    else if (strcasecmp (optionName, "thumb_size") == 0 ||
             strcasecmp (optionName, "thumb_space") == 0)
    {
        GroupSelection *group;

        CompScreen *s = getScreenFromScreenNum (screenNum);
        GROUP_SCREEN (s);

        for (group = gs->groups; group; group = group->next)
            if (group->tabBar)
            {
                BoxPtr box = &group->tabBar->region->extents;
                groupRecalcTabBarPos (group, (box->x1 + box->x2 ) / 2,
                                      box->x1, box->x2);
            }
    }
    else if (strcasecmp (optionName, "glow") == 0 ||
             strcasecmp (optionName, "glow_size") == 0)
    {
        CompScreen *s = getScreenFromScreenNum (screenNum);
        GROUP_SCREEN (s);

        CompWindow *w;

        for (w = s->windows; w; w = w->next)
        {
            GROUP_WINDOW (w);

            groupComputeGlowQuads (w, &gs->glowTexture.matrix);
            if (gw->glowQuads)
            {
                damageWindowOutputExtents (w);
                updateWindowOutputExtents (w);
                damageWindowOutputExtents (w);
            }
        }
    }
    else if (strcasecmp (optionName, "glow_type") == 0)
    {
        CompScreen *s = getScreenFromScreenNum (screenNum);
        GROUP_SCREEN (s);

        int glowType;
        GlowTextureProperties *glowProperty;

        GROUP_DISPLAY (&display);

        const BananaValue *
        option_glow_type = bananaGetOption (bananaIndex,
                                            "glow_type",
                                            s->screenNum);

        glowType = option_glow_type->i;
        glowProperty = &gd->glowTextureProperties[glowType];

        finiTexture (s, &gs->glowTexture);
        initTexture (s, &gs->glowTexture);

        imageDataToTexture (s, &gs->glowTexture,
                            glowProperty->textureData,
                            glowProperty->textureSize,
                            glowProperty->textureSize,
                            GL_RGBA, GL_UNSIGNED_BYTE);

        const BananaValue *
        option_glow = bananaGetOption (bananaIndex,
                                       "glow",
                                       s->screenNum);

        if (option_glow->b && gs->groups)
        {
            CompWindow *w;

            for (w = s->windows; w; w = w->next)
                groupComputeGlowQuads (w, &gs->glowTexture.matrix);

            damageScreen (s);
        }
    }
    else if (strcasecmp (optionName, "select_button") == 0)
        updateButton (optionValue->s, &gd->select_button);
    else if (strcasecmp (optionName, "select_single_key") == 0)
        updateKey (optionValue->s, &gd->select_single_key);
    else if (strcasecmp (optionName, "group_key") == 0)
        updateKey (optionValue->s, &gd->group_key);
    else if (strcasecmp (optionName, "ungroup_key") == 0)
        updateKey (optionValue->s, &gd->ungroup_key);
    else if (strcasecmp (optionName, "remove_key") == 0)
        updateKey (optionValue->s, &gd->remove_key);
    else if (strcasecmp (optionName, "close_key") == 0)
        updateKey (optionValue->s, &gd->close_key);
    else if (strcasecmp (optionName, "ignore_key") == 0)
        updateKey (optionValue->s, &gd->ignore_key);
    else if (strcasecmp (optionName, "tabmode_key") == 0)
        updateKey (optionValue->s, &gd->tabmode_key);
    else if (strcasecmp (optionName, "change_tab_left_key") == 0)
        updateKey (optionValue->s, &gd->change_tab_left_key);
    else if (strcasecmp (optionName, "change_tab_right_key") == 0)
        updateKey (optionValue->s, &gd->change_tab_right_key);
    else if (strcasecmp (optionName, "change_color_key") == 0)
        updateKey (optionValue->s, &gd->change_color_key);
    else if (strcasecmp (optionName, "autotab_windows") == 0)
    {
        CompScreen *s = getScreenFromScreenNum (screenNum);

        GROUP_SCREEN (s);

        int i;
        if (gs->autotab && gs->autotabCount != 0)
        {
            for (i = 0; i <= gs->autotabCount - 1; i++)
                matchFini (&gs->autotab[i]);

            free (gs->autotab);
        }

        gs->autotabCount = optionValue->list.nItem;
        gs->autotab = malloc (gs->autotabCount * sizeof (CompMatch));

        for (i = 0; i <= gs->autotabCount - 1; i++)
        {
            matchInit (&gs->autotab[i]);
            matchAddFromString (&gs->autotab[i], optionValue->list.item[i].s);
            matchUpdate (&gs->autotab[i]);
        }
    }
}
Exemple #26
0
static int mct( CONTEXT_INFO *contextInfo, 
			    const CAPABILITY_INFO *capabilityInfo,
				const BYTE *initialKey, const int keySize,
				const BYTE *initialIV, const BYTE *initialPT )
	{
	BYTE key[ AES_KEYSIZE + 8 ], iv[ AES_KEYSIZE + 8 ];
	BYTE temp[ AES_BLOCKSIZE + 8 ];
	int i;

	memcpy( key, initialKey, keySize );
	if( iv != NULL )
		memcpy( iv, initialIV, AES_BLOCKSIZE );
	memcpy( temp, initialPT, AES_BLOCKSIZE );
	for( i = 0; i < 100; i++ )
		{
		BYTE prevTemp[ AES_BLOCKSIZE + 8 ];
		int j, status;

		status = capabilityInfo->initKeyFunction( contextInfo, key, 
												  keySize );
		if( cryptStatusError( status ) )
			return( status );
		printVector( "Key", key, keySize );
		if( iv != NULL )
			printVector( "IV", iv, AES_BLOCKSIZE );
		printVector( "Plaintext", temp, AES_BLOCKSIZE );
		if( iv != NULL )
			memcpy( contextInfo->ctxConv->currentIV, iv, AES_BLOCKSIZE );
		for( j = 0; j < 1000; j++ )
			{
/*			memcpy( prevTemp, temp, AES_BLOCKSIZE ); */
			if( iv != NULL && j == 0 )
				{
				status = capabilityInfo->encryptCBCFunction( contextInfo, temp, 
															 AES_BLOCKSIZE );
				memcpy( prevTemp, temp, AES_BLOCKSIZE );
				memcpy( temp, iv, AES_BLOCKSIZE );
				}
			else
				{
				status = capabilityInfo->encryptFunction( contextInfo, temp, 
														  AES_BLOCKSIZE );
				if( iv != NULL )
					{
					BYTE tmpTemp[ AES_BLOCKSIZE + 8 ];

					memcpy( tmpTemp, temp, AES_BLOCKSIZE );
					memcpy( temp, prevTemp, AES_BLOCKSIZE );
					memcpy( prevTemp, tmpTemp, AES_BLOCKSIZE );
					}
				}
			if( cryptStatusError( status ) )
				return( status );
			}
		printVector( "Ciphertext", temp, AES_BLOCKSIZE );
		putchar( '\n' );
		status = updateKey( key, keySize, contextInfo, capabilityInfo, 
							prevTemp, temp );
		if( cryptStatusError( status ) )
			return( status );
		}
	
	return( CRYPT_OK );
	}
Exemple #27
0
//*****************************************************************************
//*****************************************************************************
int main(void) {
	//char posArray[40];
  PLL_Init();
	
	initPollingUART0();
	//initPollingUART1();
	UART0_TxPoll("\n\r\n\r\n\r*****Chiposizer V.9****");

	UART0_TxPoll("\n\rInitializing GPIO Ports...");
	initGPIOPorts();	
	
	UART0_TxPoll("\n\rInitializing PWM Modules...");
	initPWM();
	
	UART0_TxPoll("\n\rInitializing Timers...");
	initTimers();
	
	UART0_TxPoll("\n\rInitializing Effects...");
	initPremadeEffects();
	
	UART0_TxPoll("\n\rInitializing Channels...");
	initChannels();
	setCurrentChannel(ch5);

	
	UART0_TxPoll("\n\rEntering Main Loop");
	
	recordLoopNum = 0;
	
	configureUART();

	while(1){
			
		if (checkMsgs(myMsgBuffer)){
			handleLCDinput(myMsgBuffer[2], myMsgBuffer[4], currentCh->note->effects);
		}
		
		if (alertEffect) {
			alertEffect = false;
			updateAllEffects();
		}
		if (alertScan) {
			alertScan = false;
			/*if (recordLoopNum < 1000) {
				recordLoopNum++;
			} else if (!recordLoop) {
				recordLoop = true;
				cur = testList.head;
				UART0_TxPoll("\n\rBegin Record Loop");
			}
			if (!recordLoop) {
				keyNumber = scanMatrix(scanningMatrix);
				keyNumberPtr = malloc(sizeof(int8_t));
				*keyNumberPtr = keyNumber;
				add(&testList, keyNumberPtr);
			} else {
				keyNumber = *((int8_t*) cur->data);
				if (cur == testList.tail) {
					cur = testList.head;
				} else {
					cur = cur->next;
				}
			}*/
			
			keyNumber = scanMatrix(scanningMatrix);
			updateKey(currentCh->note, keyNumber);
			//printMatrix(scanningMatrix);
		}
		updateAllTuningWords();
	}
};
Exemple #28
0
void Widget::handleInput(){

	if(!initializedJoysticks){
		SDL_Init(SDL_INIT_JOYSTICK);
		if(SDL_NumJoysticks() > 0){
			guiLogger.log("found joysticks: " + std::to_string(SDL_NumJoysticks()));
			SDL_JoystickEventState(SDL_ENABLE);
			SDL_JoystickOpen(0);
		}
		else{
			guiLogger.log("found no joystick. SDL Init stat: " + std::to_string(SDL_WasInit(SDL_INIT_JOYSTICK)));
		}
		initializedJoysticks = true;
	}

	while(SDL_PollEvent(&event)){
		float *s;
		std::vector<Widget*> *widgets;
		switch(event.type){

		case SDL_JOYAXISMOTION:
			if(focused != NULL){
				if(event.jaxis.value < -3200 || event.jaxis.value > 3200){
					focused->handleAxisEvent(event.jaxis.axis, event.jaxis.value / 32767.0);
				}
				else{
					focused->handleAxisEvent(event.jaxis.axis, 0);
				}
			}
			break;
		case SDL_JOYBUTTONDOWN:
			if(focused != NULL){
				focused->handleButtonEvent(event.jbutton.button, true);
			}
			break;
		case SDL_JOYBUTTONUP:
			if(focused != NULL){
				focused->handleButtonEvent(event.jbutton.button, false);
			}
			break;

		case SDL_MOUSEMOTION:
			s = pixelToScreenSpace(event.motion.x, event.motion.y);

			updateMousePosition(s[0], s[1]);

			widgets = new std::vector<Widget*>();
			getWidgetsAt(s[0], s[1], widgets);
			Widget *w;
			//if(getFocused() != NULL && getFocused()->isListeningToMouse()){
			while(!widgets->empty()){
				w = widgets->back();
				widgets->pop_back();
				if(w->isListeningToMouse()){
					w->handleMouseMotionEvent(s[0] - w->getAbsoluteLeft(), s[1] - w->getAbsoluteTop());
					for(Widget *w1 : w->children){
						if(!w1->isFocusable()){
							w1->handleMouseMotionEvent(s[0] - w1->getAbsoluteLeft(), s[1] - w1->getAbsoluteTop());
						}
					}
				}
			}
			//}

			delete widgets;
			delete[] s;
			break;
		case SDL_MOUSEBUTTONDOWN:
			updateMouseButton(event.button.button, true);

			s = pixelToScreenSpace(event.button.x, event.button.y);

			widgets = new std::vector<Widget*>();
			getWidgetsAt(s[0], s[1], widgets);
			if(consoleActive && game::physics::pointInRect(s[0], s[1], console.getAbsoluteLeft(), console.getAbsoluteTop(), console.getWidth(), console.getHeight())){
				widgets->push_back(&console);
			}
		
			while(widgets->size() > 0){
				//Widget *w = widgets->at(i);
				Widget *w = widgets->back();
				widgets->pop_back();
				/**
				 * if the widget is listening to mouse events and focusable, let it handle the event, transforming the global event coordinates in local coordinates
				 * if the widget is also listening to keys, make it the currently focused widget
				 */
				if(w->isListeningToMouse() && w->isFocusable()){
					if(w->isListeningToKeys()){
						setFocus(w);
						//						if(focused != NULL)
						//							focused->hasFocus = false;
						//						focused = w;
						//						focused->hasFocus = true;
					}
					w->handleMouseButtonEvent(event.button.button, s[0] - w->getAbsoluteLeft(), s[1] - w->getAbsoluteTop(), true);
					for(Widget *h : w->children){
						if(!h->isFocusable()){
							h->handleMouseButtonEvent(event.button.button, s[0] - h->getAbsoluteLeft(), s[1] - h->getAbsoluteTop(), true);
						}
					}

					break;
				}
			}
			delete widgets;
			delete[] s;
			break;
		case SDL_MOUSEBUTTONUP:
			updateMouseButton(event.button.button, false);

			s = pixelToScreenSpace(event.button.x, event.button.y);

			widgets = new std::vector<Widget*>();
			getWidgetsAt(s[0], s[1], widgets);
			if(consoleActive && game::physics::pointInRect(s[0], s[1], console.getAbsoluteLeft(), console.getAbsoluteTop(), console.getWidth(), console.getHeight())){
				widgets->push_back(&console);
			}
			while(widgets->size() > 0){
				//Widget *w = widgets->at(i);
				Widget *w = widgets->back();
				widgets->pop_back();
				/**
				 * if the widget is listening to mouse events and focusable, let it handle the event, transforming the global event coordinates in local coordinates
				 * if the widget is also listening to keys, make it the currently focused widget
				 */
				if(w->isListeningToMouse() && w->isFocusable()){
					if(w->isListeningToKeys()){
						setFocus(w);
						//						if(focused != NULL)
						//							focused->hasFocus = false;
						//						focused = w;
						//						focused->hasFocus = true;
					}
					w->handleMouseButtonEvent(event.button.button, s[0] - w->getAbsoluteLeft(), s[1] - w->getAbsoluteTop(), false);
					for(Widget *h : w->children){
						if(!h->isFocusable()){
							h->handleMouseButtonEvent(event.button.button, s[0] - h->getAbsoluteLeft(), s[1] - h->getAbsoluteTop(), false);
						}
					}

					break;
				}
			}
			delete widgets;
			delete[] s;
			break;
		case SDL_MOUSEWHEEL:
			if(getFocused() != NULL && getFocused()->isListeningToMouse()){
				getFocused()->handleMouseWheelEvent(event.wheel.y);
			}
			break;
		case SDL_KEYDOWN:
			updateKey(event.key.keysym.scancode, true);
			//mapKey(event.key.keysym.scancode, true);
			if(event.key.keysym.sym == SDLK_ESCAPE){
				if(game::isInHomescreen()){
					render::stop();
					game::stop();
				}
				else{
					game::toHomescreenWidget();
					audio::clearMusicQueue();
					audio::queueMusic("sfx/temp/pippin_the_hunchback.wav");
					audio::nextSong();
				}
			}
#ifdef unix
			if(event.key.keysym.sym == SDLK_BACKQUOTE && (event.key.keysym.mod & (KMOD_SHIFT | KMOD_CAPS)) > 0){
#else
#ifdef windows
				if(event.key.keysym.sym == SDLK_BACKQUOTE){ // TODO find way to get shift mod with wine SDL
#else
					if(false){
#endif
#endif
						consoleActive = !consoleActive;
						if(consoleActive){
							setFocus(&console);
						}
						else if(getFocused() == &console){
							if(children.size() > 0){
								setFocus(children[0]);
							}
							else{
								setFocus(NULL);
							}
						}
					}
					if(focused != NULL){
						focused->handleKeyEvent(event.key.keysym.sym, event.key.keysym.mod, true);
					}
					break;
		case SDL_TEXTINPUT:
			if(focused != NULL){
				focused->handleTextEvent(std::string(event.text.text));
			}
			break;
		case SDL_KEYUP:
			updateKey(event.key.keysym.scancode, false);
			//mapKey(event.key.keysym.scancode, false);
			if(focused != NULL){
				focused->handleKeyEvent(event.key.keysym.sym, event.key.keysym.mod, false);
			}
			break;
				}
			}

		}

		void Widget::render(float updateFactor){
			render::setRenderTarget(render::HUD); //TODO unnecessary repeated setting of render Target
			for(Widget *w : children){
				render::setScissorArea(w->getAbsoluteLeft(), w->getAbsoluteTop() + w->getHeight(), w->getWidth(), w->getHeight());
				w->render(updateFactor);
			}
		}

		void Widget::renderConsole(float updateFactor){
			render::setRenderTarget(render::HUD);
			if(consoleActive){
				render::setScissorArea(console.getAbsoluteLeft(), console.getAbsoluteTop() + console.getHeight(), console.getWidth(), console.getHeight());
				console.render(updateFactor);
			}
		}
 void append(const KoColor& data) {
     int pos = findPos(data);
     if (pos > -1) updateKey(pos);
     else appendNew(data);
 }
Exemple #30
0
static Tree updateKey (Tree pl, Tree key, Tree val)
{
	if (isNil(pl)) 				return cons ( cons(key,val), gGlobal->nil );
	if (left(hd(pl)) == key) 	return cons ( cons(key,val), tl(pl) );
	/*  left(hd(pl)) != key	*/	return cons ( hd(pl), updateKey( tl(pl), key, val ));
}