//---------------------------------------------------------
void CVIEW_Map_Control::On_Key_Down(wxKeyEvent &event)
{
	if( m_pMap->Find_Layer(Get_Active_Layer()) && Get_Active_Layer()->Edit_On_Key_Down(event.GetKeyCode()) )
	{
		return;
	}

	switch( event.GetKeyCode() )
	{
	default:
		event.Skip();
		break;

	case WXK_PAGEUP:
		_Zoom(m_pMap->Get_Extent().Get_Center(), true);
		break;

	case WXK_PAGEDOWN:
		_Zoom(m_pMap->Get_Extent().Get_Center(), false);
		break;

	case WXK_LEFT:
		_Move(wxPoint(-10,   0));
		break;

	case WXK_RIGHT:
		_Move(wxPoint( 10,   0));
		break;

	case WXK_UP:
		_Move(wxPoint(  0, -10));
		break;

	case WXK_DOWN:
		_Move(wxPoint(  0,  10));
		break;

	case WXK_F2:
		m_pMap->SaveAs_Image();
		break;

	case 'C':
		if( event.GetModifiers() == wxMOD_CONTROL )
		{
			m_pMap->SaveAs_Image_Clipboard(false);
		}
		else if( event.GetModifiers() == wxMOD_ALT )
		{
			m_pMap->SaveAs_Image_Clipboard(GetClientSize().x, GetClientSize().y, -1);
		}
		break;

	case 'L':
		if( event.GetModifiers() == wxMOD_CONTROL )
		{
			m_pMap->SaveAs_Image_Clipboard(true);
		}
	}
}
Пример #2
0
		void SymbolTable::EvalFunctionReferenceClosure()
		{
			for (auto & func : Functions)
			{
				List<String> funcList;
				EnumerableHashSet<String> funcSet;
				for (auto & ref : func.Value->ReferencedFunctions)
				{
					funcList.Add(ref);
					funcSet.Add(ref);
				}
				for (int i = 0; i < funcList.Count(); i++)
				{
					RefPtr<FunctionSymbol> funcSym;
					if (Functions.TryGetValue(funcList[i], funcSym))
					{
						for (auto rfunc : funcSym->ReferencedFunctions)
						{
							if (funcSet.Add(rfunc))
								funcList.Add(rfunc);
						}
					}
				}
				func.Value->ReferencedFunctions = _Move(funcSet);
			}
		}
Пример #3
0
		List<String>& PipelineSymbol::GetWorldTopologyOrder()
		{
			if (WorldTopologyOrder.Count() != 0)
				return WorldTopologyOrder;
			List<String> rs;
			HashSet<String> rsSet;
			bool changed = true;
			while (changed)
			{
				changed = false;
				for (auto & w : WorldDependency)
				{
					if (!rsSet.Contains(w.Key))
					{
						bool canAdd = true;
						for (auto & dw : w.Value)
							if (!rsSet.Contains(dw))
							{
								canAdd = false;
								break;
							}
						if (canAdd)
						{
							rsSet.Add(w.Key);
							rs.Add(w.Key);
							changed = true;
						}
					}
				}
			}
			WorldTopologyOrder = _Move(rs);
			return WorldTopologyOrder;
		}
//---------------------------------------------------------
void CVIEW_Map_Control::On_Mouse_MUp(wxMouseEvent &event)
{
	if( HasCapture() )
	{
		ReleaseMouse();
	}

	_Draw_Inverse(m_Mouse_Down, event.GetPosition());
	m_Drag_Mode	= TOOL_INTERACTIVE_DRAG_NONE;

	switch( m_Mode )
	{
	//-----------------------------------------------------
	case MAP_MODE_SELECT:
		break;

	//-----------------------------------------------------
	case MAP_MODE_DISTANCE:
		break;

	//-----------------------------------------------------
	case MAP_MODE_ZOOM:
		break;

	//-----------------------------------------------------
	case MAP_MODE_PAN:
		break;

	//-----------------------------------------------------
	case MAP_MODE_PAN_DOWN:
		Set_Mode(MAP_MODE_ZOOM);
		_Move(m_Mouse_Down, event.GetPosition());
		break;
	}
}
//---------------------------------------------------------
void CVIEW_Map_Control::On_Mouse_LUp(wxMouseEvent &event)
{
	if( HasCapture() )
	{
		ReleaseMouse();
	}

	//-----------------------------------------------------
	if( m_Mode != MAP_MODE_SELECT && (event.ControlDown() || event.AltDown()) )	// clipboard copy ?
	{
		return;
	}

	//-----------------------------------------------------
	_Draw_Inverse(m_Mouse_Down, event.GetPosition());
	m_Drag_Mode	= TOOL_INTERACTIVE_DRAG_NONE;

	switch( m_Mode )
	{
	//-----------------------------------------------------
	case MAP_MODE_SELECT:
		if( g_pTool )
		{
			g_pTool->Execute(_Get_Client2World(event.GetPosition()), TOOL_INTERACTIVE_LUP, GET_KEYS(event));
		}
		else if( m_pMap->Find_Layer(Get_Active_Layer()) )
		{
			Get_Active_Layer()->Edit_On_Mouse_Up(_Get_Client2World(event.GetPosition()), _Get_Client2World(1.0), GET_KEYS(event)|TOOL_INTERACTIVE_KEY_LEFT);
		}
		break;

	//-----------------------------------------------------
	case MAP_MODE_DISTANCE:
		_Distance_Add(event.GetPosition());
		break;

	//-----------------------------------------------------
	case MAP_MODE_ZOOM:
		_Zoom(m_Mouse_Down, event.GetPosition());
		break;

	//-----------------------------------------------------
	case MAP_MODE_PAN:
		break;

	//-----------------------------------------------------
	case MAP_MODE_PAN_DOWN:
		Set_Mode(MAP_MODE_PAN);
		_Move(m_Mouse_Down, event.GetPosition());
		break;
	}
}
Пример #6
0
bool
SdfNamespaceEdit_Namespace::Apply(
    const SdfNamespaceEdit& edit,
    std::string* whyNot)
{
    // If newPath is empty we want to remove the object.
    if (edit.newPath.IsEmpty()) {
        return _Remove(edit.currentPath, whyNot);
    }
    else if (edit.currentPath != edit.newPath) {
        return _Move(edit.currentPath, edit.newPath, whyNot);
    }
    else {
        // Reorder -- Ignore the reorder in our virtual namespace.
        return true;
    }
}
Пример #7
0
void statusbar_set_statustext(const char *text, int text_time)
{
  video_canvas_t *canvas;

  for (canvas = canvaslist; canvas; canvas = canvas->next) {
    struct Window *window;
    struct TextExtent te;
    int x, width, height, max_chars;
    int basex, basey;

    if (!canvas->os->has_statusbar ||
        canvas->waiting_for_resize) continue;

    window = canvas->os->window;
    width = window->Width - window->BorderLeft - window->BorderRight;
    height = window->Height - window->BorderTop - window->BorderBottom - statusbar_get_status_height();
    basex = window->BorderLeft;
    basey = window->BorderTop;

    if (canvas->os->font) {
      SetFont(window->RPort, canvas->os->font);
    }
    /* else we use system default font */

    x = width - (canvas->os->disk_width * enabled_drives) - (tape_enabled ? canvas->os->tape_width : 0);

    SetAPen(window->RPort, 0);
    SetBPen(window->RPort, 0);
    _RectFill(window->RPort, 0, height, x - 1, height + statusbar_get_status_height() - 1);

    max_chars = TextFit(window->RPort, text, strlen(text), &te, NULL, 1, x - (7 * 2), 20);

    SetAPen(window->RPort, canvas->os->pens[b_black]);
    _Move(window->RPort, 7, height + 13);
    Text(window->RPort, text, max_chars /* strlen(text) */);
  }
  statusbar_statustext_time=text_time;
}
Пример #8
0
		void ShaderSymbol::SortComponents(List<ShaderComponentSymbol*>& comps)
		{
			comps.Sort([&](ShaderComponentSymbol*c0, ShaderComponentSymbol*c1)
			{
				return c0->Implementations.First()->SyntaxNode->Position < c1->Implementations.First()->SyntaxNode->Position;
			});
			HashSet<ShaderComponentSymbol*> allSymbols, addedSymbols;
			for (auto & comp : comps)
				allSymbols.Add(comp);
			List<ShaderComponentSymbol*> sorted;
			bool changed = true;
			while (changed)
			{
				changed = false;
				for (auto & comp : comps)
				{
					if (!addedSymbols.Contains(comp))
					{
						bool isFirst = true;
						for (auto & impl : comp->Implementations)
							for (auto & dep : impl->DependentComponents)
								if (allSymbols.Contains(dep) && !addedSymbols.Contains(dep))
								{
									isFirst = false;
									goto loopEnd;
								}
					loopEnd:;
						if (isFirst)
						{
							addedSymbols.Add(comp);
							sorted.Add(comp);
							changed = true;
						}
					}
				}
			}
			comps = _Move(sorted);
		}
//---------------------------------------------------------
bool CVIEW_Map_Control::_Move(const wxPoint &Move)
{
	wxPoint	A(Move), B(0, 0);

	return( _Move(A, B) );
}
Пример #10
0
void KariudoKen::Move()
{
	Animate();
	_Move();

}
Пример #11
0
	int ChoiceForm::AutotuneHelper(HashSet<String> & selectedChoices, EnumerableDictionary<String, Spire::Compiler::ShaderChoiceValue>& currentChoices, float timeBudget, bool countOnly)
	{
		auto choices = choiceControl->GetChoices(currentShaderName, currentChoices);
		List<Spire::Compiler::ShaderChoice> filteredChoices;
		for (auto & choice : choices)
			if (!currentChoices.ContainsKey(choice.ChoiceName))
				filteredChoices.Add(choice);
		choices = _Move(filteredChoices);
		// find first non-trivial choice
		Spire::Compiler::ShaderChoice * currentChoice = nullptr;
		for (auto & choice : choices)
		{
			if (choice.Options.Count() > 1 && selectedChoices.Contains(choice.ChoiceName))
			{
				currentChoice = &choice;
				break;
			}
		}
		if (currentChoice)
		{
			int count = 0;
			for (auto & opt : currentChoice->Options)
			{
				EnumerableDictionary<String, Spire::Compiler::ShaderChoiceValue> newChoices = currentChoices;
				newChoices[currentChoice->ChoiceName] = opt;
				count += AutotuneHelper(selectedChoices, newChoices, timeBudget, countOnly);
			}
			return count;
		}
		else
		{
			if (!countOnly)
			{
				printf("Testing shader variant...");
				// compile and evaluate
				auto schedule = GenerateSchedule(currentChoices, EnumerableDictionary<String, EnumerableDictionary<String, String>>());
				choiceControl->RecompileShader(currentShaderName, schedule);
				// render 1000 frames and measure time
				float minTime = 1e30f;
				for (int f = 0; f < 20; f++)
				{
					glFinish();
					auto timeP = CoreLib::Diagnostics::PerformanceCounter::Start();
					for (int i = 0; i < 10; i++)
					{
						choiceControl->RenderFrame();
					}
					glFinish();

					auto time = (float)CoreLib::Diagnostics::PerformanceCounter::ToSeconds(CoreLib::Diagnostics::PerformanceCounter::End(timeP)) * 100.0f;
					if (time < minTime)
						minTime = time;
				}


				choiceControl->UpdateWindow();
				auto frameData = ReadFrameData(choiceControl->RenderFrame());
				float error = MeasureError(referenceFrame, frameData);
				float value = 0;
				if (minTime < timeBudget)
					value = error;
				else
					value = 20.0f + minTime;
				if (value < currentBestValue)
				{
					currentBestValue = value;
					currentBestChoices = currentChoices;
				}
				autotuningLog << minTime << L"," << error<<EndLine;
				printf("%f ms, error: %f\n", minTime, error);
			}
			return 1;
		}
	}
Пример #12
0
bool Shape::MoveRight(const Panel* panel)
{
    return _Move(panel, 0, 1);
}
Пример #13
0
bool CVIEW_Map_Control::_Move(wxPoint ptMove)
{
	return( _Move(ptMove, wxPoint(0, 0)) );
}
Пример #14
0
bool Shape::MoveDown(const Panel* panel)
{
    return _Move(panel, 1, 0);
}
Пример #15
0
void statusbar_refresh(int drive_number)
{
  video_canvas_t *canvas;
  int i;

  if (drive_number == REFRESH_ALL) {
    enabled_drives = 0;
    for (i=0; i<DRIVE_NUM; i++) {
      if (status_enabled & (1 << i)) {
        status_map[enabled_drives++] = i;
      }
    }
  }

  for (canvas = canvaslist; canvas; canvas = canvas->next) {
    struct Window *window;
    char str[32];
    int x, width, height;
    int basex, basey;

    if (!canvas->os->has_statusbar ||
        canvas->waiting_for_resize) continue;

    window = canvas->os->window;
    width = window->Width - window->BorderLeft - window->BorderRight;
    height = window->Height - window->BorderTop - window->BorderBottom - statusbar_get_status_height();
    basex = window->BorderLeft;
    basey = window->BorderTop;

    if (canvas->os->font) {
      SetFont(window->RPort, canvas->os->font);
    }
    /* else we use system default font */

    if (drive_number == REFRESH_ALL) {
      x = width - (canvas->os->disk_width * enabled_drives) - (tape_enabled ? canvas->os->tape_width : 0);
      SetAPen(window->RPort, 0);
      SetBPen(window->RPort, 0);
      _RectFill(window->RPort, 0, height, x - 1, height + statusbar_get_status_height() - 1);
    }

    for (i=0; i<enabled_drives; i++) {
      int drive = status_map[i];

      if ((drive_number != REFRESH_ALL) && (drive_number != drive)) continue;

      sprintf(str, "%2d: %2d.%01d", drive + 8, (int)status_track[drive], (int)(status_track[drive] * 10 - (int)status_track[drive] * 10));

      x = width - (canvas->os->disk_width * (enabled_drives - i));

      SetAPen(window->RPort, 0);
      SetBPen(window->RPort, 0);
      _RectFill(window->RPort, x, height, x + canvas->os->disk_width - 1, height + statusbar_get_status_height() - 1);

      SetAPen(window->RPort, canvas->os->pens[b_black]);
      _Move(window->RPort, x, height + 13);
      Text(window->RPort, str, strlen(str));
      x += canvas->os->disk_width - (10 + 7);

      SetAPen(window->RPort, canvas->os->pens[(status_led[drive] ? (drive_active_led[drive] ? b_green : b_red) : b_black)]);
      _RectFill(window->RPort, x, height + 4, x + 10, height + 14);
    }

    if ((tape_enabled) && ((drive_number == REFRESH_ALL) || (drive_number == TAPE_NUM))) {
      int motor_color;
      int record_led;

      /* motor */
      if (tape_motor) {
        motor_color = b_yellow;
      } else {
        motor_color = b_grey;
      }

      x = width - (canvas->os->disk_width * enabled_drives) - (tape_enabled ? canvas->os->tape_width : 0);

      SetAPen(window->RPort, 0);
      SetBPen(window->RPort, 0);
      _RectFill(window->RPort, x, height, x + canvas->os->tape_width - 1, height + statusbar_get_status_height() - 1);

      SetAPen(window->RPort, canvas->os->pens[motor_color]);
      _RectFill(window->RPort, x, height + 4, x + 10, height + 14);

      /* control */
      record_led = b_black;
      switch (tape_control) {
        case DATASETTE_CONTROL_STOP:
          SetAPen(window->RPort, canvas->os->pens[b_black]);
          _RectFill(window->RPort, x + 2, height + 4 + 2, x + 10 - 2, height + 14 - 2);
          break;
        case DATASETTE_CONTROL_RECORD:
          record_led = b_red;
        case DATASETTE_CONTROL_START:
          SetAPen(window->RPort, canvas->os->pens[b_black]);
          LINE(x + 2, height + 4 + 2, x + 2, height + 14 - 2);
          LINE(x + 3, height + 4 + 3, x + 3, height + 14 - 3);
          LINE(x + 4, height + 4 + 4, x + 4, height + 14 - 4);
          LINE(x + 5, height + 4 + 5, x + 5, height + 14 - 5);
          break;
        case DATASETTE_CONTROL_REWIND:
          SetAPen(window->RPort, canvas->os->pens[b_black]);
          LINE(x + 5, height + 4 + 2, x + 2, height + 4 + 5);
          LINE(x + 2, height + 4 + 5, x + 5, height + 14 - 2);
          LINE(x + 5 + 3, height + 4 + 2, x + 2 + 3, height + 4 + 5);
          LINE(x + 2 + 3, height + 4 + 5, x + 5 + 3, height + 14 - 2);
          break;
        case DATASETTE_CONTROL_FORWARD:
          SetAPen(window->RPort, canvas->os->pens[b_black]);
          LINE(x + 2, height + 4 + 2, x + 5, height + 4 + 5);
          LINE(x + 5, height + 4 + 5, x + 2, height + 14 - 2);
          LINE(x + 2 + 3, height + 4 + 2, x + 5 + 3, height + 4 + 5);
          LINE(x + 5 + 3, height + 4 + 5, x + 2 + 3, height + 14 - 2);
          break;
      }
      SetAPen(window->RPort, canvas->os->pens[record_led]);
      _RectFill(window->RPort, x + 2 + 14, height + 4 + 2, x + 10 - 2 + 14, height + 14 - 2);

      /* counter */
      sprintf(str, "%03d", tape_counter);
      SetAPen(window->RPort, canvas->os->pens[b_black]);
      _Move(window->RPort, x + 28, height + 13);
      Text(window->RPort, str, strlen(str));
    }
  }
}
Пример #16
0
		void ShaderIR::EliminateDeadCode()
		{
			// mark entry points
			auto MarkUsing = [&](String compName, String userWorld)
			{
				if (auto defs = DefinitionsByComponent.TryGetValue(compName))
				{
					if (auto def = defs->TryGetValue(userWorld))
						(*def)->IsEntryPoint = true;
					else
					{
						for (auto & world : Shader->Pipeline->WorldDependency[userWorld]())
						{
							if (auto def2 = defs->TryGetValue(world))
							{
								(*def2)->IsEntryPoint = true;
								break;
							}
						}
					}
				}
			};
			for (auto & impOp : Shader->Pipeline->SyntaxNode->ImportOperators)
				for (auto & ref : impOp->Usings)
					MarkUsing(ref.Content, impOp->DestWorld.Content);
			for (auto & w : Shader->Pipeline->SyntaxNode->Worlds)
				for (auto & ref : w->Usings)
					MarkUsing(ref.Content, w->Name.Content);
			for (auto & comp : Definitions)
				if (comp->Implementation->ExportWorlds.Contains(comp->World) ||
					Shader->Pipeline->IsAbstractWorld(comp->World) &&
					(comp->Implementation->SyntaxNode->LayoutAttributes.ContainsKey(L"Pinned") || Shader->Pipeline->Worlds[comp->World]().SyntaxNode->LayoutAttributes.ContainsKey(L"Pinned")))
				{
					comp->IsEntryPoint = true;
				}

			List<ComponentDefinitionIR*> workList;
			HashSet<ComponentDefinitionIR*> referencedDefs;
			for (auto & def : Definitions)
			{
				if (def->IsEntryPoint)
				{
					if (referencedDefs.Add(def.Ptr()))
						workList.Add(def.Ptr());
				}
			}
			for (int i = 0; i < workList.Count(); i++)
			{
				auto def = workList[i];
				for (auto & dep : def->Dependency)
				{
					if (referencedDefs.Add(dep))
						workList.Add(dep);
				}
			}
			List<RefPtr<ComponentDefinitionIR>> newDefinitions;
			for (auto & def : Definitions)
			{
				if (referencedDefs.Contains(def.Ptr()))
				{
					newDefinitions.Add(def);
					EnumerableHashSet<ComponentDefinitionIR*> newSet;
					for (auto & comp : def->Users)
						if (referencedDefs.Contains(comp))
						{
							newSet.Add(comp);
						}
					def->Users = newSet;
					newSet.Clear();
					for (auto & comp : def->Dependency)
						if (referencedDefs.Contains(comp))
						{
							newSet.Add(comp);
						}
					def->Dependency = newSet;
				}
			}
			Definitions = _Move(newDefinitions);
			for (auto & kv : DefinitionsByComponent)
			{
				for (auto & def : kv.Value)
					if (!referencedDefs.Contains(def.Value))
						kv.Value.Remove(def.Key);
			}
		}
Пример #17
0
bool
PCL5Driver::NextBand(BBitmap* bitmap, BPoint* offset)
{
	DBGMSG(("> nextBand\n"));

	try {
		BRect bounds = bitmap->Bounds();

		RECT rc;
		rc.left = (int)bounds.left;
		rc.top = (int)bounds.top;
		rc.right = (int)bounds.right;
		rc.bottom = (int)bounds.bottom;

		int height = rc.bottom - rc.top + 1;

		int x = (int)offset->x;
		int y = (int)offset->y;

		int pageHeight = GetPageHeight();

		if (y + height > pageHeight)
			height = pageHeight - y;

		rc.bottom = height - 1;

		DBGMSG(("height = %d\n", height));
		DBGMSG(("x = %d\n", x));
		DBGMSG(("y = %d\n", y));

		if (get_valid_rect(bitmap, &rc)) {

			DBGMSG(("validate rect = %d, %d, %d, %d\n",
				rc.left, rc.top, rc.right, rc.bottom));

			x = rc.left;
			y += rc.top;

			int width = rc.right - rc.left + 1;
			int widthByte = (width + 7) / 8;
				// byte boundary
			int height = rc.bottom - rc.top + 1;
			int in_size = widthByte;
			int out_size = (widthByte * 6 + 4) / 5;
			int delta = bitmap->BytesPerRow();

			DBGMSG(("width = %d\n", width));
			DBGMSG(("widthByte = %d\n", widthByte));
			DBGMSG(("height = %d\n", height));
			DBGMSG(("in_size = %d\n", in_size));
			DBGMSG(("out_size = %d\n", out_size));
			DBGMSG(("delta = %d\n", delta));
			DBGMSG(("renderobj->Get_pixel_depth() = %d\n", fHalftone->GetPixelDepth()));

			uchar* ptr = static_cast<uchar*>(bitmap->Bits())
						+ rc.top * delta
						+ (rc.left * fHalftone->GetPixelDepth()) / 8;

			int compressionMethod;
			int compressedSize;
			const uchar* buffer;

			uchar* in_buffer  = new uchar[in_size];
			uchar* out_buffer = new uchar[out_size];

			auto_ptr<uchar> _in_buffer (in_buffer);
			auto_ptr<uchar> _out_buffer(out_buffer);

			DBGMSG(("move\n"));

			_Move(x, y);
			_StartRasterGraphics(width, height);

			const bool color = GetJobData()->GetColor() == JobData::kColor;
			const int num_planes = color ? 3 : 1;
			
			if (color) {
				fHalftone->SetPlanes(Halftone::kPlaneRGB1);
				fHalftone->SetBlackValue(Halftone::kLowValueMeansBlack);
			}
			
			for (int i = rc.top; i <= rc.bottom; i++) {
			
				for (int plane = 0; plane < num_planes; plane ++) {
										
					fHalftone->Dither(in_buffer, ptr, x, y, width);
							
					compressedSize = pack_bits(out_buffer, in_buffer, in_size);
					
					if (compressedSize + _BytesToEnterCompressionMethod(2)
						< in_size + _BytesToEnterCompressionMethod(0)) {
						compressionMethod = 2; // back bits
						buffer = out_buffer;
					} else {
						compressionMethod = 0; // uncompressed
						buffer = in_buffer;
						compressedSize = in_size;
					}
		
					_RasterGraphics(
						compressionMethod,
						buffer,
						compressedSize,
						plane == num_planes - 1);
				
				}

				ptr  += delta;
				y++;
			}

			_EndRasterGraphics();

		} else
			DBGMSG(("band bitmap is clean.\n"));

		if (y >= pageHeight) {
			offset->x = -1.0;
			offset->y = -1.0;
		} else
			offset->y += height;

		DBGMSG(("< nextBand\n"));
		return true;
	}
	catch (TransportException& err) {
		BAlert* alert = new BAlert("", err.What(), "OK");
		alert->Go();
		return false;
	} 
}
Пример #18
0
bool Shape::MoveLeft(const Panel* panel)
{
    return _Move(panel, 0, -1);
}