@SuppressWarnings("all")
  public ZoomPanDrawingView(Context context, AttributeSet attrs) {
    super(context, attrs);
    fHolder = getHolder();
    fHolder.addCallback(this);

    int width = ((Activity) context).getWindowManager().getDefaultDisplay().getWidth();
    int height = ((Activity) context).getWindowManager().getDefaultDisplay().getHeight();
    fCanvasManager = new DrawManager(width, height);

    fDrawListener = new ViewDrawListener();
    fCanvasManager.setDrawListener(fDrawListener);
    fZoomManager = new ZoomPanTouchListener(fCanvasManager);

    fViewMatrix = new Matrix();
    fZoomManager.setViewMatrix(fViewMatrix);

    fInputMatrix = new Matrix();
    fZoomManager.setInputMatrix(fInputMatrix);

    fCanvasManager.setInputMatrix(fInputMatrix);

    fDrawLock = new ReentrantLock();
    fDrawCondition = fDrawLock.newCondition();
    fDrawFlag = true;
    fZoomFlag = false;

    fWidth = fCanvasManager.getWidth();
    fHeight = fCanvasManager.getHeight();

    fCorners = new float[4];
  }
  @SuppressWarnings("all")
  public ZoomPanDrawingView(Context context, DrawManager aCanvasManager) {
    super(context);
    fHolder = getHolder();
    fHolder.addCallback(this);
    fCanvasManager = aCanvasManager;
    fDrawListener = new ViewDrawListener();
    fCanvasManager.setDrawListener(fDrawListener);
    fZoomManager = new ZoomPanTouchListener(fCanvasManager);

    fViewMatrix = new Matrix();
    fZoomManager.setViewMatrix(fViewMatrix);

    fInputMatrix = new Matrix();
    fZoomManager.setInputMatrix(fInputMatrix);

    fCanvasManager.setInputMatrix(fInputMatrix);

    fDrawLock = new ReentrantLock();
    fDrawCondition = fDrawLock.newCondition();
    fDrawFlag = true;
    fZoomFlag = false;

    fWidth = fCanvasManager.getWidth();
    fHeight = fCanvasManager.getHeight();

    fCorners = new float[4];
  }
Ejemplo n.º 3
0
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // Build scenarios:
    scenarios = new ArrayList<List<Icon>>();
    scenarios.add(start); // Add start scenario (manually created)
    // generate as many scenarios as defined in the constant
    scenarios.addAll(ScenGenerator.generateScenarios(SCENARIO_COUNT));

    // Get text views from layout
    sctimetv = (TextView) findViewById(R.id.sctimetv);
    scerrortv = (TextView) findViewById(R.id.scerrortv);
    nsctimetv = (TextView) findViewById(R.id.nsctimetv);
    nscerrortv = (TextView) findViewById(R.id.nscerrorstv);
    setEvaluationLabelsVisible(false);

    // Get reset button from layout
    resetbutton = (Button) findViewById(R.id.resetbutton);
    resetbutton.setOnClickListener(
        new OnClickListener() {

          @Override
          public void onClick(View v) { // restart the activity
            Intent intent = getIntent();
            overridePendingTransition(0, 0);
            intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
            finish();

            overridePendingTransition(0, 0);
            startActivity(intent);
          }
        });

    // Initialize TestData Arrays
    errors = new int[scenarios.size()];
    times = new long[scenarios.size()];

    // Create objects:
    scenario = new Scenario(scenarios.get(currentScenario));
    scatter = new Scatter();

    // Register drawers to DrawManager
    drawManager = (DrawManager) findViewById(R.id.drawManager);
    drawManager.registerDrawer(scenario);
    drawManager.registerDrawer(scatter);

    initListeners();

    // Log.i("Filepath", Environment.getExternalStorageDirectory()
    // .getAbsolutePath() + "/hello.txt");

  }
  @Override
  public void surfaceCreated(SurfaceHolder surfaceHolder) {
    setOnTouchListener(fZoomManager);
    if (fThread != null) {
      fThread.stopThread();
      fThread.fInstance = null;
    }
    fThread = new ViewThread(this);
    fThread.start();

    fCanvasManager.redraw();
  }
    @Override
    public boolean onTouch(View view, MotionEvent event) {
      switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
          if (fState == STATE.INIT && event.getPointerCount() == 1) {
            fState = STATE.WAIT;
            fPreviousEvents.add(
                new DrawManager.MyMotionEvent(event.getAction(), event.getX(), event.getY()));
          }
          if (fState == STATE.INIT && event.getPointerCount() == 2) {
            fState = STATE.ZOOM_PAN;
            initZoom(event);
          }
          break;
        case MotionEvent.ACTION_MOVE:
          if (fState == STATE.WAIT && event.getPointerCount() == 1) {
            if (trueMove(event)) {
              fState = STATE.DRAW;
              for (DrawManager.MyMotionEvent previousEvent : fPreviousEvents) {
                fDelegate.onTouch(view, previousEvent);
              }
              fDelegate.onTouch(view, event);
              fPreviousEvents.clear();
            } else {
              fPreviousEvents.add(
                  new DrawManager.MyMotionEvent(event.getAction(), event.getX(), event.getY()));
            }

          } else if (fState == STATE.WAIT && event.getPointerCount() == 2) {
            fState = STATE.ZOOM_PAN;
            // init zoom pan
            initZoom(event);
          } else if (fState == STATE.ZOOM_PAN) {
            // update zoom//pan
            updateZoomAndPan(event);
          } else if (fState == STATE.DRAW) {
            fDelegate.onTouch(view, event);
          }
          break;
        case MotionEvent.ACTION_UP:
          if (fState == STATE.ZOOM_PAN) {
            // finish zoom
            closeAction();
          } else if (fState == STATE.WAIT) {
            for (DrawManager.MyMotionEvent previousEvent : fPreviousEvents) {
              fDelegate.onTouch(view, previousEvent);
            }
            fPreviousEvents.clear();
            fDelegate.onTouch(view, event);
          } else if (fState == STATE.DRAW && event.getPointerCount() == 1) {
            fDelegate.onTouch(view, event);
          }
          fState = STATE.INIT;
          fPreviousEvents.clear();
          break;
      }
      return true;
    }
Ejemplo n.º 6
0
  /**
   * The main function of the game. Something fun starts here. :)
   *
   * @param args passed command line arguments.
   */
  public static void main(String[] args) {

    if (!Resource.getInstance().initialize()) {
      JOptionPane.showMessageDialog(
          null, "Resource loading fail.", "Cannot open game", JOptionPane.ERROR_MESSAGE);
      return;
    }
    if (!LevelFileManager.getInstance().initialize()) {
      JOptionPane.showMessageDialog(
          null, "Level files loading fail.", "Cannot open game", JOptionPane.ERROR_MESSAGE);
      return;
    }

    // Create JFrame
    JFrame frame = new JFrame(Constants.PROGRAM_NAME);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    // frame.setResizable(false);
    frame.setMinimumSize(Constants.MINIMUM_WINDOW_SIZE);
    frame
        .getContentPane()
        .addComponentListener(
            new ComponentListener() {

              @Override
              public void componentShown(ComponentEvent arg0) {}

              @Override
              public void componentResized(ComponentEvent arg0) {
                DrawManager.getInstance()
                    .setCanvasSize(
                        frame.getContentPane().getWidth(), frame.getContentPane().getHeight());
              }

              @Override
              public void componentMoved(ComponentEvent arg0) {}

              @Override
              public void componentHidden(ComponentEvent arg0) {}
            });

    if (Constants.IS_FULLSCREEN) {
      frame.setUndecorated(true);
      frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
    } else {
      frame.getContentPane().setPreferredSize(Constants.DEFAULT_SCREEN_SIZE);
      frame.pack();
    }

    InputManager.setListenerTo(frame);

    frame.getContentPane().setBackground(ColorSwatch.BACKGROUND);
    frame.setVisible(true);

    // Add canvas to the frame
    DrawManager.getInstance().addCanvasInto(frame);
    DrawManager.getInstance()
        .setCanvasSize(frame.getContentPane().getWidth(), frame.getContentPane().getHeight());

    // Set initial scene

    SceneManager.getInstance().setNextScene(new scene.mainmenu.MainMenuScene(true));
    // SceneManager.getInstance().setNextScene(new stage.GameStage(GameStageType.PLAY));

    // Game looper
    final long maximumWaitTime = 1000000000 / Constants.MAX_FRAME_PER_SECOND;
    long updateTime;
    Resource.getInstance().themeSong.loop();
    while (true) {
      // Perform a game update (including game logic and painting)
      updateTime = System.nanoTime();
      SceneManager.getInstance().update();
      updateTime = System.nanoTime() - updateTime;

      if (updateTime < maximumWaitTime) {
        FPSCollector.add(Constants.MAX_FRAME_PER_SECOND);
      } else {
        FPSCollector.add(Math.round(1000000000 / updateTime));
      }

      // Perform sleeping to limit maximum FPS
      if (updateTime < maximumWaitTime) {
        try {
          Thread.sleep((maximumWaitTime - updateTime) / 1000000);
        } catch (InterruptedException e) {
          Thread.interrupted();
          e.printStackTrace();
        }
      }
    }
  }
Ejemplo n.º 7
0
 @Override
 protected void onResume() {
   super.onResume();
   drawManager.resume();
 }
Ejemplo n.º 8
0
 @Override
 protected void onPause() {
   super.onPause();
   drawManager.pause();
 }
Ejemplo n.º 9
0
  // hello world
  private void initListeners() {
    detector =
        new GestureDetector(
            this,
            new GestureDetector.SimpleOnGestureListener() {
              @Override
              public boolean onFling(
                  MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {

                Log.i("Fling", "Weee");

                return true;
              }
            });
    drawManager.setOnTouchListener(
        new OnTouchListener() {

          @Override
          public boolean onTouch(View v, MotionEvent event) {

            boolean result = detector.onTouchEvent(event);

            if (result) {
              Log.i("result", "true");
              return result;
            }

            // clear last selection
            selectedIcon = null;

            switch (event.getAction()) {
              case MotionEvent.ACTION_MOVE:

                // check if same segment had been selected before
                // to avoid multiple events for 1 selection
                Icon prev = scatter.getSelected();
                selectedIcon = scatter.getItemAt(event.getX(), event.getY());

                if (selectedIcon == null || selectedIcon.equals(prev)) {
                  break;
                }

                // play sound resource on hover
                if (selectedIcon.getSoundResource() != -1) {
                  MediaPlayer mp =
                      MediaPlayer.create(MainActivity.this, selectedIcon.getSoundResource());
                  mp.start();
                }
                break;

              case MotionEvent.ACTION_UP:

                // Get the selected target from either scatter or standard
                // selection
                if (scatter.isVisible()) {
                  selectedIcon = scatter.getSelected();
                  scatter.hide();
                } else if (!isscatter) {
                  Icon currentIcon;
                  // standard selection with point x,y
                  // reverse order to select the topmost icon first
                  for (int i = scenario.getTargets().size() - 1; i >= 0; i--) {
                    currentIcon = scenario.getTargets().get(i);
                    if (currentIcon.getCircle().contains(x, y)) {
                      selectedIcon = currentIcon;
                      break;
                    }
                  }
                }

                // start screen sets if scatter selection or standard
                // selection should work depending on which icon was
                // selected
                if (selectedIcon != null && currentScenario == 0) {
                  if (selectedIcon.equals(scenario.getTargets().get(0))) {
                    isscatter = true;
                    errors[0] = 0;
                    times[0] = 0L;
                  } else if (selectedIcon.equals(scenario.getTargets().get(5))) {
                    errors[0] = 1;
                    times[0] = 1L;
                    isscatter = false;
                  }
                }

                // determine end condition (valid selection)
                if (selectedIcon != null && selectedIcon.isTarget()) {

                  // A valid selection has been made, register the time of
                  // the scenario
                  if (currentScenario != 0) {
                    // stop timer
                    times[currentScenario] = (System.nanoTime() - startTime) / 1000000;
                  }

                  // start timer
                  startTime = System.nanoTime();

                  // set the next scenario to be loaded
                  currentScenario = (currentScenario + 1) % scenarios.size();

                  // Load the scenario:
                  scenario.setScenario(scenarios.get(currentScenario));

                  // when the next scenario is the start screen (a test
                  // cycle is done)
                  if (currentScenario == 0) {
                    isscatter = false;

                    // output arrays into textviews

                    float avgTime = 0;
                    float avgErrors = 0;
                    for (int i = 1; i < errors.length; i++) {

                      avgTime += times[i];
                      avgErrors += errors[i];
                    }
                    avgTime /= errors.length - 1;
                    avgErrors /= errors.length - 1;

                    String timesText = "Time: " + avgTime;
                    String errorsText = "Errors: " + avgErrors;

                    String sdCard = Environment.getExternalStorageDirectory().getAbsolutePath();
                    File testResults = new File(sdCard + "/testResults.txt");

                    try {
                      PrintWriter pw =
                          new PrintWriter(new BufferedWriter(new FileWriter(testResults, true)));

                      pw.println(new Date(System.currentTimeMillis()).toGMTString());
                      pw.println(Arrays.toString(times));
                      pw.println(Arrays.toString(errors));

                      pw.close();

                    } catch (FileNotFoundException e) {
                      // TODO Auto-generated catch block
                      e.printStackTrace();
                    } catch (IOException e) {
                      // TODO Auto-generated catch block
                      e.printStackTrace();
                    }

                    if (errors[0] == 0) { // doing scatter
                      sctimetv.setText(timesText);
                      scerrortv.setText(errorsText);
                    } else { // doing standard selection
                      nsctimetv.setText(timesText);
                      nscerrortv.setText(errorsText);
                    }

                    setStartTitlesVisible(true);
                    setEvaluationLabelsVisible(true);

                    // reinitialize arrays
                    errors = new int[scenarios.size()];
                    times = new long[scenarios.size()];

                  } else { // When the next scenario is NOT the start
                    // screen
                    setStartTitlesVisible(false);
                    setEvaluationLabelsVisible(false);
                  }
                } else {
                  // invalid selection (wrong or no target)

                  // play error sound?

                  ++errors[currentScenario];
                }
                break;
              case MotionEvent.ACTION_DOWN:
                x = event.getX();
                y = event.getY();

                break;
            }

            return result;
          }
        });

    drawManager.setOnLongClickListener(
        new OnLongClickListener() {

          @Override
          public boolean onLongClick(View v) {

            // if scatter selection active
            if (isscatter || currentScenario == 0) {
              // get list of selected objects
              Circle scattercenter = new Circle(x, y, 50);
              List<Icon> temp = scattercenter.findScatterIcons(scenario.getTargets());
              if (temp.size() < 1) {
                return false;
              }
              scatter.show(x, y, temp);
            }
            return false;
          }
        });
  }